/*******************************************************************************
* Copyright (c) 2000, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.eval;
import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.CastExpression;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.ParameterizedQualifiedTypeReference;
import org.eclipse.jdt.internal.compiler.ast.TypeReference;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemMethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ProblemReasons;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
public class CodeSnippetAllocationExpression extends AllocationExpression implements ProblemReasons, EvaluationConstants {
EvaluationContext evaluationContext;
FieldBinding delegateThis;
/**
* CodeSnippetAllocationExpression constructor comment.
*/
public CodeSnippetAllocationExpression(EvaluationContext evaluationContext) {
this.evaluationContext= evaluationContext;
}
public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
int pc= codeStream.position;
MethodBinding codegenBinding= this.binding.original();
ReferenceBinding allocatedType= codegenBinding.declaringClass;
if (codegenBinding.canBeSeenBy(allocatedType, this, currentScope)) {
codeStream.new_(allocatedType);
if (valueRequired) {
codeStream.dup();
}
// better highlight for allocation: display the type individually
codeStream.recordPositionsFrom(pc, this.type.sourceStart);
// handling innerclass instance allocation - enclosing instance arguments
if (allocatedType.isNestedType()) {
codeStream.generateSyntheticEnclosingInstanceValues(
currentScope,
allocatedType,
enclosingInstance(),
this);
}
// generate the arguments for constructor
if (this.arguments != null) {
for (int i= 0, count= this.arguments.length; i < count; i++) {
this.arguments[i].generateCode(currentScope, codeStream, true);
}
}
// handling innerclass instance allocation - outer local arguments
if (allocatedType.isNestedType()) {
codeStream.generateSyntheticOuterArgumentValues(
currentScope,
allocatedType,
this);
}
// invoke constructor
codeStream.invoke(Opcodes.OPC_invokespecial, codegenBinding, null /* default declaringClass */);
} else {
// private emulation using reflect
codeStream.generateEmulationForConstructor(currentScope, codegenBinding);
// generate arguments
if (this.arguments != null) {
int argsLength= this.arguments.length;
codeStream.generateInlinedValue(argsLength);
codeStream.newArray(currentScope.createArrayType(currentScope.getType(TypeConstants.JAVA_LANG_OBJECT, 3), 1));
codeStream.dup();
for (int i= 0; i < argsLength; i++) {
codeStream.generateInlinedValue(i);
this.arguments[i].generateCode(currentScope, codeStream, true);
TypeBinding parameterBinding= codegenBinding.parameters[i];
if (parameterBinding.isBaseType() && parameterBinding != TypeBinding.NULL) {
codeStream.generateBoxingConversion(codegenBinding.parameters[i].id);
}
codeStream.aastore();
if (i < argsLength - 1) {
codeStream.dup();
}
}
} else {
codeStream.generateInlinedValue(0);
codeStream.newArray(currentScope.createArrayType(currentScope.getType(TypeConstants.JAVA_LANG_OBJECT, 3), 1));
}
codeStream.invokeJavaLangReflectConstructorNewInstance();
codeStream.checkcast(allocatedType);
}
codeStream.recordPositionsFrom(pc, this.sourceStart);
}
/* Inner emulation consists in either recording a dependency
* link only, or performing one level of propagation.
*
* Dependency mechanism is used whenever dealing with source target
* types, since by the time we reach them, we might not yet know their
* exact need.
*/
public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
// not supported yet
}
public void manageSyntheticAccessIfNecessary(BlockScope currentScope, FlowInfo flowInfo) {
// do nothing
}
public TypeBinding resolveType(BlockScope scope) {
// Propagate the type checking to the arguments, and check if the constructor is defined.
this.constant= Constant.NotAConstant;
this.resolvedType= this.type.resolveType(scope, true /* check bounds*/); // will check for null after args are resolved
checkParameterizedAllocation: {
if (this.type instanceof ParameterizedQualifiedTypeReference) { // disallow new X<String>.Y<Integer>()
ReferenceBinding currentType= (ReferenceBinding)this.resolvedType;
if (currentType == null)
return currentType;
do {
// isStatic() is answering true for toplevel types
if ((currentType.modifiers & ClassFileConstants.AccStatic) != 0)
break checkParameterizedAllocation;
if (currentType.isRawType())
break checkParameterizedAllocation;
} while ((currentType= currentType.enclosingType()) != null);
ParameterizedQualifiedTypeReference qRef= (ParameterizedQualifiedTypeReference)this.type;
for (int i= qRef.typeArguments.length - 2; i >= 0; i--) {
if (qRef.typeArguments[i] != null) {
scope.problemReporter().illegalQualifiedParameterizedTypeAllocation(this.type, this.resolvedType);
break;
}
}
}
}
// resolve type arguments (for generic constructor call)
if (this.typeArguments != null) {
int length= this.typeArguments.length;
boolean argHasError= scope.compilerOptions().sourceLevel < ClassFileConstants.JDK1_5;
this.genericTypeArguments= new TypeBinding[length];
for (int i= 0; i < length; i++) {
TypeReference typeReference= this.typeArguments[i];
if ((this.genericTypeArguments[i]= typeReference.resolveType(scope, true /* check bounds*/)) == null) {
argHasError= true;
}
if (argHasError && typeReference instanceof Wildcard) {
scope.problemReporter().illegalUsageOfWildcard(typeReference);
}
}
if (argHasError) {
if (this.arguments != null) { // still attempt to resolve arguments
for (int i= 0, max= this.arguments.length; i < max; i++) {
this.arguments[i].resolveType(scope);
}
}
return null;
}
}
// buffering the arguments' types
boolean argsContainCast= false;
TypeBinding[] argumentTypes= Binding.NO_PARAMETERS;
if (this.arguments != null) {
boolean argHasError= false;
int length= this.arguments.length;
argumentTypes= new TypeBinding[length];
for (int i= 0; i < length; i++) {
Expression argument= this.arguments[i];
if (argument instanceof CastExpression) {
argument.bits|= DisableUnnecessaryCastCheck; // will check later on
argsContainCast= true;
}
if ((argumentTypes[i]= argument.resolveType(scope)) == null) {
argHasError= true;
}
}
if (argHasError) {
return this.resolvedType;
}
}
if (this.resolvedType == null) {
return null;
}
if (!this.resolvedType.canBeInstantiated()) {
scope.problemReporter().cannotInstantiate(this.type, this.resolvedType);
return this.resolvedType;
}
ReferenceBinding allocatedType= (ReferenceBinding)this.resolvedType;
if (!(this.binding= scope.getConstructor(allocatedType, argumentTypes, this)).isValidBinding()) {
if (this.binding instanceof ProblemMethodBinding
&& ((ProblemMethodBinding)this.binding).problemId() == NotVisible) {
if (this.evaluationContext.declaringTypeName != null) {
this.delegateThis= scope.getField(scope.enclosingSourceType(), DELEGATE_THIS, this);
if (this.delegateThis == null) {
if (this.binding.declaringClass == null) {
this.binding.declaringClass= allocatedType;
}
if (this.type != null && !this.type.resolvedType.isValidBinding()) {
return null;
}
scope.problemReporter().invalidConstructor(this, this.binding);
return this.resolvedType;
}
} else {
if (this.binding.declaringClass == null) {
this.binding.declaringClass= allocatedType;
}
if (this.type != null && !this.type.resolvedType.isValidBinding()) {
return null;
}
scope.problemReporter().invalidConstructor(this, this.binding);
return this.resolvedType;
}
CodeSnippetScope localScope= new CodeSnippetScope(scope);
MethodBinding privateBinding= localScope.getConstructor((ReferenceBinding)this.delegateThis.type, argumentTypes, this);
if (!privateBinding.isValidBinding()) {
if (this.binding.declaringClass == null) {
this.binding.declaringClass= allocatedType;
}
if (this.type != null && !this.type.resolvedType.isValidBinding()) {
return null;
}
scope.problemReporter().invalidConstructor(this, this.binding);
return this.resolvedType;
} else {
this.binding= privateBinding;
}
} else {
if (this.binding.declaringClass == null) {
this.binding.declaringClass= allocatedType;
}
if (this.type != null && !this.type.resolvedType.isValidBinding()) {
return null;
}
scope.problemReporter().invalidConstructor(this, this.binding);
return this.resolvedType;
}
}
if (isMethodUseDeprecated(this.binding, scope, true)) {
scope.problemReporter().deprecatedMethod(this.binding, this);
}
if (this.arguments != null) {
for (int i= 0; i < this.arguments.length; i++) {
TypeBinding parameterType= this.binding.parameters[i];
TypeBinding argumentType= argumentTypes[i];
this.arguments[i].computeConversion(scope, parameterType, argumentType);
if (argumentType.needsUncheckedConversion(parameterType)) {
scope.problemReporter().unsafeTypeConversion(this.arguments[i], argumentType, parameterType);
}
}
if (argsContainCast) {
CastExpression.checkNeedForArgumentCasts(scope, null, allocatedType, this.binding, this.arguments, argumentTypes, this);
}
}
if (allocatedType.isRawType() && this.binding.hasSubstitutedParameters()) {
scope.problemReporter().unsafeRawInvocation(this, this.binding);
}
if (this.typeArguments != null && this.binding.original().typeVariables == Binding.NO_TYPE_VARIABLES) {
scope.problemReporter().unnecessaryTypeArgumentsForMethodInvocation(this.binding, this.genericTypeArguments, this.typeArguments);
}
return allocatedType;
}
}