X-Git-Url: http://git.phpeclipse.com diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/ExplicitConstructorCall.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/ExplicitConstructorCall.java index ff0da65..ecf0b95 100644 --- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/ExplicitConstructorCall.java +++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/ExplicitConstructorCall.java @@ -1,17 +1,16 @@ /******************************************************************************* - * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others. + * Copyright (c) 2000, 2003 IBM Corporation and others. * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Common Public License v0.5 + * are made available under the terms of the Common Public License v1.0 * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/cpl-v05.html + * http://www.eclipse.org/legal/cpl-v10.html * * Contributors: * IBM Corporation - initial API and implementation - ******************************************************************************/ + *******************************************************************************/ package net.sourceforge.phpdt.internal.compiler.ast; -import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor; -import net.sourceforge.phpdt.internal.compiler.codegen.CodeStream; +import net.sourceforge.phpdt.internal.compiler.ASTVisitor; import net.sourceforge.phpdt.internal.compiler.flow.FlowContext; import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo; import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope; @@ -24,21 +23,25 @@ import net.sourceforge.phpdt.internal.compiler.lookup.SourceTypeBinding; import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding; import net.sourceforge.phpdt.internal.compiler.lookup.VariableBinding; -public class ExplicitConstructorCall - extends Statement - implements InvocationSite { - +public class ExplicitConstructorCall extends Statement implements + InvocationSite { + public Expression[] arguments; + public Expression qualification; + public MethodBinding binding; public int accessMode; public final static int ImplicitSuper = 1; + public final static int Super = 2; + public final static int This = 3; public VariableBinding[][] implicitArguments; + boolean discardEnclosingInstance; MethodBinding syntheticAccessor; @@ -47,43 +50,35 @@ public class ExplicitConstructorCall this.accessMode = accessMode; } - public FlowInfo analyseCode( - BlockScope currentScope, - FlowContext flowContext, - FlowInfo flowInfo) { + public FlowInfo analyseCode(BlockScope currentScope, + FlowContext flowContext, FlowInfo flowInfo) { - // must verify that exceptions potentially thrown by this expression are caught in the method. + // must verify that exceptions potentially thrown by this expression are + // caught in the method. try { ((MethodScope) currentScope).isConstructorCall = true; // process enclosing instance if (qualification != null) { - flowInfo = - qualification - .analyseCode(currentScope, flowContext, flowInfo) - .unconditionalInits(); + flowInfo = qualification.analyseCode(currentScope, flowContext, + flowInfo).unconditionalInits(); } // process arguments if (arguments != null) { for (int i = 0, max = arguments.length; i < max; i++) { - flowInfo = - arguments[i] - .analyseCode(currentScope, flowContext, flowInfo) - .unconditionalInits(); + flowInfo = arguments[i].analyseCode(currentScope, + flowContext, flowInfo).unconditionalInits(); } } ReferenceBinding[] thrownExceptions; if ((thrownExceptions = binding.thrownExceptions) != NoExceptions) { // check exceptions - flowContext.checkExceptionHandlers( - thrownExceptions, - (accessMode == ImplicitSuper) - ? (AstNode) currentScope.methodScope().referenceContext - : (AstNode) this, - flowInfo, - currentScope); + flowContext.checkExceptionHandlers(thrownExceptions, + (accessMode == ImplicitSuper) ? (ASTNode) currentScope + .methodScope().referenceContext + : (ASTNode) this, flowInfo, currentScope); } manageEnclosingInstanceAccessIfNecessary(currentScope); manageSyntheticAccessIfNecessary(currentScope); @@ -95,56 +90,67 @@ public class ExplicitConstructorCall /** * Constructor call code generation - * - * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope - * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream + * + * @param currentScope + * net.sourceforge.phpdt.internal.compiler.lookup.BlockScope + * @param codeStream + * net.sourceforge.phpdt.internal.compiler.codegen.CodeStream */ - public void generateCode(BlockScope currentScope, CodeStream codeStream) { - - if ((bits & IsReachableMASK) == 0) { - return; - } - try { - ((MethodScope) currentScope).isConstructorCall = true; - - int pc = codeStream.position; - codeStream.aload_0(); - - // handling innerclass constructor invocation - ReferenceBinding targetType; - if ((targetType = binding.declaringClass).isNestedType()) { - codeStream.generateSyntheticArgumentValues( - currentScope, - targetType, - discardEnclosingInstance ? null : qualification, - this); - } - // regular code gen - if (arguments != null) { - for (int i = 0, max = arguments.length; i < max; i++) { - arguments[i].generateCode(currentScope, codeStream, true); - } - } - if (syntheticAccessor != null) { - // synthetic accessor got some extra arguments appended to its signature, which need values - for (int i = 0, - max = syntheticAccessor.parameters.length - binding.parameters.length; - i < max; - i++) { - codeStream.aconst_null(); - } - codeStream.invokespecial(syntheticAccessor); - } else { - codeStream.invokespecial(binding); - } - codeStream.recordPositionsFrom(pc, this.sourceStart); - } finally { - ((MethodScope) currentScope).isConstructorCall = false; - } - } - + // public void generateCode(BlockScope currentScope, CodeStream codeStream) + // { + // + // if ((bits & IsReachableMASK) == 0) { + // return; + // } + // try { + // ((MethodScope) currentScope).isConstructorCall = true; + // + // int pc = codeStream.position; + // codeStream.aload_0(); + // + // // handling innerclass constructor invocation + // ReferenceBinding targetType = binding.declaringClass; + // // handling innerclass instance allocation - enclosing instance arguments + // if (targetType.isNestedType()) { + // codeStream.generateSyntheticEnclosingInstanceValues( + // currentScope, + // targetType, + // discardEnclosingInstance ? null : qualification, + // this); + // } + // // regular code gen + // if (arguments != null) { + // for (int i = 0, max = arguments.length; i < max; i++) { + // arguments[i].generateCode(currentScope, codeStream, true); + // } + // } + // // handling innerclass instance allocation - outer local arguments + // if (targetType.isNestedType()) { + // codeStream.generateSyntheticOuterArgumentValues( + // currentScope, + // targetType, + // this); + // } + // if (syntheticAccessor != null) { + // // synthetic accessor got some extra arguments appended to its signature, + // which need values + // for (int i = 0, + // max = syntheticAccessor.parameters.length - binding.parameters.length; + // i < max; + // i++) { + // codeStream.aconst_null(); + // } + // codeStream.invokespecial(syntheticAccessor); + // } else { + // codeStream.invokespecial(binding); + // } + // codeStream.recordPositionsFrom(pc, this.sourceStart); + // } finally { + // ((MethodScope) currentScope).isConstructorCall = false; + // } + // } public boolean isImplicitSuper() { - //return true if I'm of these compiler added statement super(); + // return true if I'm of these compiler added statement super(); return (accessMode == ImplicitSuper); } @@ -159,51 +165,52 @@ public class ExplicitConstructorCall return true; } - /* 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. + /* + * 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. */ void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope) { ReferenceBinding superType; - // perform some emulation work in case there is some and we are inside a local type only + // perform some emulation work in case there is some and we are inside a + // local type only if ((superType = binding.declaringClass).isNestedType() - && currentScope.enclosingSourceType().isLocalType()) { + && currentScope.enclosingSourceType().isLocalType()) { if (superType.isLocalType()) { ((LocalTypeBinding) superType).addInnerEmulationDependent( - currentScope, - qualification != null, - true); - // request direct access + currentScope, qualification != null); } else { - // locally propagate, since we already now the desired shape for sure - currentScope.propagateInnerEmulation(superType, qualification != null, true); - // request direct access - + // locally propagate, since we already now the desired shape for + // sure + currentScope.propagateInnerEmulation(superType, + qualification != null); } } } public void manageSyntheticAccessIfNecessary(BlockScope currentScope) { - // perform some emulation work in case there is some and we are inside a local type only + // perform some emulation work in case there is some and we are inside a + // local type only if (binding.isPrivate() && (accessMode != This)) { - if (currentScope - .environment() - .options - .isPrivateConstructorAccessChangingVisibility) { - binding.tagForClearingPrivateModifier(); - // constructor will not be dumped as private, no emulation required thus - } else { - syntheticAccessor = - ((SourceTypeBinding) binding.declaringClass).addSyntheticMethod(binding); - currentScope.problemReporter().needToEmulateMethodAccess(binding, this); - } + // if (currentScope + // .environment() + // .options + // .isPrivateConstructorAccessChangingVisibility) { + // binding.tagForClearingPrivateModifier(); + // // constructor will not be dumped as private, no emulation + // required thus + // } else { + syntheticAccessor = ((SourceTypeBinding) binding.declaringClass) + .addSyntheticMethod(binding, isSuperAccess()); + currentScope.problemReporter().needToEmulateMethodAccess(binding, + this); + // } } } @@ -226,18 +233,19 @@ public class ExplicitConstructorCall // qualification should be from the type of the enclosingType if (qualification != null) { if (accessMode != Super) { - scope.problemReporter().unnecessaryEnclosingInstanceSpecification( - qualification, - receiverType); + scope.problemReporter() + .unnecessaryEnclosingInstanceSpecification( + qualification, receiverType); } ReferenceBinding enclosingType = receiverType.enclosingType(); if (enclosingType == null) { - scope.problemReporter().unnecessaryEnclosingInstanceSpecification( - qualification, - receiverType); + scope.problemReporter() + .unnecessaryEnclosingInstanceSpecification( + qualification, receiverType); discardEnclosingInstance = true; } else { - TypeBinding qTb = qualification.resolveTypeExpecting(scope, enclosingType); + TypeBinding qTb = qualification.resolveTypeExpecting(scope, + enclosingType); qualification.implicitWidening(qTb, qTb); } } @@ -255,16 +263,20 @@ public class ExplicitConstructorCall return; } if ((binding = scope.getConstructor(receiverType, argTypes, this)) - .isValidBinding()) { + .isValidBinding()) { if (isMethodUseDeprecated(binding, scope)) scope.problemReporter().deprecatedMethod(binding, this); - // see for user-implicit widening conversion + // see for user-implicit widening conversion if (arguments != null) { int length = arguments.length; TypeBinding[] paramTypes = binding.parameters; for (int i = 0; i < length; i++) - arguments[i].implicitWidening(paramTypes[i], argTypes[i]); + arguments[i].implicitWidening(paramTypes[i], + argTypes[i]); + } + if (binding.isPrivate()) { + binding.modifiers |= AccPrivateUsed; } } else { if (binding.declaringClass == null) @@ -288,6 +300,26 @@ public class ExplicitConstructorCall // ignore for here } + public StringBuffer printStatement(int indent, StringBuffer output) { + + printIndent(indent, output); + if (qualification != null) + qualification.printExpression(0, output).append('.'); + if (accessMode == This) { + output.append("this("); //$NON-NLS-1$ + } else { + output.append("super("); //$NON-NLS-1$ + } + if (arguments != null) { + for (int i = 0; i < arguments.length; i++) { + if (i > 0) + output.append(", "); //$NON-NLS-1$ + arguments[i].printExpression(0, output); + } + } + return output.append(");"); //$NON-NLS-1$ + } + public String toString(int tab) { String s = tabString(tab); @@ -308,7 +340,7 @@ public class ExplicitConstructorCall return s; } - public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) { + public void traverse(ASTVisitor visitor, BlockScope scope) { if (visitor.visit(this, scope)) { if (qualification != null) { @@ -322,4 +354,4 @@ public class ExplicitConstructorCall } visitor.endVisit(this, scope); } -} \ No newline at end of file +}