net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/internal/compiler/ast/QualifiedAllocationExpression.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpeclipse.internal.compiler.ast;
  12
  13 import net.sourceforge.phpdt.internal.compiler.IAbstractSyntaxTreeVisitor;
  14 import net.sourceforge.phpdt.internal.compiler.flow.FlowContext;
  15 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
  16 import net.sourceforge.phpdt.internal.compiler.lookup.BlockScope;
  17 import net.sourceforge.phpdt.internal.compiler.lookup.LocalTypeBinding;
  18 import net.sourceforge.phpdt.internal.compiler.lookup.MethodBinding;
  19 import net.sourceforge.phpdt.internal.compiler.lookup.ReferenceBinding;
  20 import net.sourceforge.phpdt.internal.compiler.lookup.TypeBinding;
  21
  22 /**
  23  * Variation on allocation, where can be specified an enclosing instance and an anonymous type
  24  */
  25 public class QualifiedAllocationExpression extends AllocationExpression {
  26
  27         //qualification may be on both side
  28         public Expression enclosingInstance;
  29         public AnonymousLocalTypeDeclaration anonymousType;
  30         public ReferenceBinding superTypeBinding;
  31
  32         public QualifiedAllocationExpression() {
  33         }
  34
  35         public QualifiedAllocationExpression(AnonymousLocalTypeDeclaration anonymousType) {
  36                 this.anonymousType = anonymousType;
  37         }
  38
  39         public FlowInfo analyseCode(
  40                 BlockScope currentScope,
  41                 FlowContext flowContext,
  42                 FlowInfo flowInfo) {
  43
  44                 // analyse the enclosing instance
  45                 if (enclosingInstance != null) {
  46                         flowInfo = enclosingInstance.analyseCode(currentScope, flowContext, flowInfo);
  47                 }
  48
  49                 // check captured variables are initialized in current context (26134)
  50                 checkCapturedLocalInitializationIfNecessary(
  51                         this.superTypeBinding == null ? this.binding.declaringClass : this.superTypeBinding,
  52                         currentScope,
  53                         flowInfo);
  54
  55                 // process arguments
  56                 if (arguments != null) {
  57                         for (int i = 0, count = arguments.length; i < count; i++) {
  58                                 flowInfo = arguments[i].analyseCode(currentScope, flowContext, flowInfo);
  59                         }
  60                 }
  61
  62                 // analyse the anonymous nested type
  63                 if (anonymousType != null) {
  64                         flowInfo = anonymousType.analyseCode(currentScope, flowContext, flowInfo);
  65                 }
  66
  67                 // record some dependency information for exception types
  68                 ReferenceBinding[] thrownExceptions;
  69                 if (((thrownExceptions = binding.thrownExceptions).length) != 0) {
  70                         // check exception handling
  71                         flowContext.checkExceptionHandlers(
  72                                 thrownExceptions,
  73                                 this,
  74                                 flowInfo,
  75                                 currentScope);
  76                 }
  77                 manageEnclosingInstanceAccessIfNecessary(currentScope);
  78                 manageSyntheticAccessIfNecessary(currentScope);
  79                 return flowInfo;
  80         }
  81
  82         public Expression enclosingInstance() {
  83
  84                 return enclosingInstance;
  85         }
  86
  87 //      public void generateCode(
  88 //              BlockScope currentScope,
  89 //              CodeStream codeStream,
  90 //              boolean valueRequired) {
  91 //
  92 //              int pc = codeStream.position;
  93 //              ReferenceBinding allocatedType = binding.declaringClass;
  94 //              codeStream.new_(allocatedType);
  95 //              if (valueRequired) {
  96 //                      codeStream.dup();
  97 //              }
  98 //              // better highlight for allocation: display the type individually
  99 //              codeStream.recordPositionsFrom(pc, type.sourceStart);
 100 //
 101 //              // handling innerclass instance allocation - enclosing instance arguments
 102 //              if (allocatedType.isNestedType()) {
 103 //                      codeStream.generateSyntheticEnclosingInstanceValues(
 104 //                              currentScope,
 105 //                              allocatedType,
 106 //                              enclosingInstance(),
 107 //                              this);
 108 //              }
 109 //              // generate the arguments for constructor
 110 //              if (arguments != null) {
 111 //                      for (int i = 0, count = arguments.length; i < count; i++) {
 112 //                              arguments[i].generateCode(currentScope, codeStream, true);
 113 //                      }
 114 //              }
 115 //              // handling innerclass instance allocation - outer local arguments
 116 //              if (allocatedType.isNestedType()) {
 117 //                      codeStream.generateSyntheticOuterArgumentValues(
 118 //                              currentScope,
 119 //                              allocatedType,
 120 //                              this);
 121 //              }
 122 //
 123 //              // invoke constructor
 124 //              if (syntheticAccessor == null) {
 125 //                      codeStream.invokespecial(binding);
 126 //              } else {
 127 //                      // synthetic accessor got some extra arguments appended to its signature, which need values
 128 //                      for (int i = 0,
 129 //                              max = syntheticAccessor.parameters.length - binding.parameters.length;
 130 //                              i < max;
 131 //                              i++) {
 132 //                              codeStream.aconst_null();
 133 //                      }
 134 //                      codeStream.invokespecial(syntheticAccessor);
 135 //              }
 136 //              codeStream.recordPositionsFrom(pc, this.sourceStart);
 137 //
 138 //              if (anonymousType != null) {
 139 //                      anonymousType.generateCode(currentScope, codeStream);
 140 //              }
 141 //      }
 142
 143         public boolean isSuperAccess() {
 144
 145                 // necessary to lookup super constructor of anonymous type
 146                 return anonymousType != null;
 147         }
 148
 149         /* Inner emulation consists in either recording a dependency
 150          * link only, or performing one level of propagation.
 151          *
 152          * Dependency mechanism is used whenever dealing with source target
 153          * types, since by the time we reach them, we might not yet know their
 154          * exact need.
 155          */
 156         public void manageEnclosingInstanceAccessIfNecessary(BlockScope currentScope) {
 157
 158                 ReferenceBinding allocatedType;
 159
 160                 // perform some emulation work in case there is some and we are inside a local type only
 161                 if ((allocatedType = binding.declaringClass).isNestedType()
 162                         && currentScope.enclosingSourceType().isLocalType()) {
 163
 164                         if (allocatedType.isLocalType()) {
 165                                 ((LocalTypeBinding) allocatedType).addInnerEmulationDependent(currentScope, enclosingInstance != null);
 166                         } else {
 167                                 // locally propagate, since we already now the desired shape for sure
 168                                 currentScope.propagateInnerEmulation(allocatedType, enclosingInstance != null);
 169                         }
 170                 }
 171         }
 172
 173         public TypeBinding resolveType(BlockScope scope) {
 174
 175                 // added for code assist...cannot occur with 'normal' code
 176                 if (anonymousType == null && enclosingInstance == null) {
 177                         return super.resolveType(scope);
 178                 }
 179
 180                 // Propagate the type checking to the arguments, and checks if the constructor is defined.
 181                 // ClassInstanceCreationExpression ::= Primary '.' 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
 182                 // ClassInstanceCreationExpression ::= Name '.' 'new' SimpleName '(' ArgumentListopt ')' ClassBodyopt
 183                 // ==> by construction, when there is an enclosing instance the typename may NOT be qualified
 184                 // ==> therefore by construction the type is always a SingleTypeReferenceType instead of being either
 185                 // sometime a SingleTypeReference and sometime a QualifedTypeReference
 186
 187                 constant = NotAConstant;
 188                 TypeBinding enclosingInstanceType = null;
 189                 TypeBinding receiverType = null;
 190                 boolean hasError = false;
 191                 if (anonymousType == null) { //----------------no anonymous class------------------------
 192                         if ((enclosingInstanceType = enclosingInstance.resolveType(scope)) == null){
 193                                 hasError = true;
 194                         } else if (enclosingInstanceType.isBaseType() || enclosingInstanceType.isArrayType()) {
 195                                 scope.problemReporter().illegalPrimitiveOrArrayTypeForEnclosingInstance(
 196                                         enclosingInstanceType,
 197                                         enclosingInstance);
 198                                 hasError = true;
 199                         } else if ((this.resolvedType = receiverType = ((SingleTypeReference) type).resolveTypeEnclosing(
 200                                                         scope,
 201                                                         (ReferenceBinding) enclosingInstanceType)) == null) {
 202                                 hasError = true;
 203                         }
 204                         // will check for null after args are resolved
 205                         TypeBinding[] argumentTypes = NoParameters;
 206                         if (arguments != null) {
 207                                 int length = arguments.length;
 208                                 argumentTypes = new TypeBinding[length];
 209                                 for (int i = 0; i < length; i++)
 210                                         if ((argumentTypes[i] = arguments[i].resolveType(scope)) == null){
 211                                                 hasError = true;
 212                                         }
 213                         }
 214                         // limit of fault-tolerance
 215                         if (hasError) return receiverType;
 216
 217                         if (!receiverType.canBeInstantiated()) {
 218                                 scope.problemReporter().cannotInstantiate(type, receiverType);
 219                                 return receiverType;
 220                         }
 221                         if ((this.binding = scope.getConstructor((ReferenceBinding) receiverType, argumentTypes, this))
 222                                         .isValidBinding()) {
 223                                 if (isMethodUseDeprecated(binding, scope))
 224                                         scope.problemReporter().deprecatedMethod(this.binding, this);
 225
 226                                 if (arguments != null)
 227                                         for (int i = 0; i < arguments.length; i++)
 228                                                 arguments[i].implicitWidening(this.binding.parameters[i], argumentTypes[i]);
 229                         } else {
 230                                 if (this.binding.declaringClass == null)
 231                                         this.binding.declaringClass = (ReferenceBinding) receiverType;
 232                                 scope.problemReporter().invalidConstructor(this, this.binding);
 233                                 return receiverType;
 234                         }
 235
 236                         // The enclosing instance must be compatible with the innermost enclosing type
 237                         ReferenceBinding expectedType = this.binding.declaringClass.enclosingType();
 238                         if (enclosingInstanceType.isCompatibleWith(expectedType))
 239                                 return receiverType;
 240                         scope.problemReporter().typeMismatchErrorActualTypeExpectedType(
 241                                 this.enclosingInstance,
 242                                 enclosingInstanceType,
 243                                 expectedType);
 244                         return receiverType;
 245                 }
 246
 247                 //--------------there is an anonymous type declaration-----------------
 248                 if (this.enclosingInstance != null) {
 249                         if ((enclosingInstanceType = this.enclosingInstance.resolveType(scope)) == null) {
 250                                 hasError = true;
 251                         } else if (enclosingInstanceType.isBaseType() || enclosingInstanceType.isArrayType()) {
 252                                 scope.problemReporter().illegalPrimitiveOrArrayTypeForEnclosingInstance(
 253                                         enclosingInstanceType,
 254                                         this.enclosingInstance);
 255                                 hasError = true;
 256                         } else {
 257                                 receiverType = ((SingleTypeReference) type).resolveTypeEnclosing(
 258                                                                                 scope,
 259                                                                                 (ReferenceBinding) enclosingInstanceType);
 260                         }
 261                 } else {
 262                         receiverType = type.resolveType(scope);
 263                 }
 264                 if (receiverType == null) {
 265                         hasError = true;
 266                 } else if (((ReferenceBinding) receiverType).isFinal()) {
 267                         scope.problemReporter().anonymousClassCannotExtendFinalClass(type, receiverType);
 268                         hasError = true;
 269                 }
 270                 TypeBinding[] argumentTypes = NoParameters;
 271                 if (arguments != null) {
 272                         int length = arguments.length;
 273                         argumentTypes = new TypeBinding[length];
 274                         for (int i = 0; i < length; i++)
 275                                 if ((argumentTypes[i] = arguments[i].resolveType(scope)) == null) {
 276                                         hasError = true;
 277                                 }
 278                 }
 279                 // limit of fault-tolerance
 280                 if (hasError) {
 281                                 return receiverType;
 282                 }
 283
 284                 // an anonymous class inherits from java.lang.Object when declared "after" an interface
 285                 this.superTypeBinding =
 286                         receiverType.isInterface() ? scope.getJavaLangObject() : (ReferenceBinding) receiverType;
 287                 MethodBinding inheritedBinding =
 288                         scope.getConstructor(this.superTypeBinding, argumentTypes, this);
 289                 if (!inheritedBinding.isValidBinding()) {
 290                         if (inheritedBinding.declaringClass == null)
 291                                 inheritedBinding.declaringClass = this.superTypeBinding;
 292                         scope.problemReporter().invalidConstructor(this, inheritedBinding);
 293                         return null;
 294                 }
 295                 if (enclosingInstance != null) {
 296                         if (!enclosingInstanceType.isCompatibleWith(inheritedBinding.declaringClass.enclosingType())) {
 297                                 scope.problemReporter().typeMismatchErrorActualTypeExpectedType(
 298                                         enclosingInstance,
 299                                         enclosingInstanceType,
 300                                         inheritedBinding.declaringClass.enclosingType());
 301                                 return null;
 302                         }
 303                 }
 304
 305                 // this promotion has to be done somewhere: here or inside the constructor of the
 306                 // anonymous class. We do it here while the constructor of the inner is then easier.
 307                 if (arguments != null)
 308                         for (int i = 0; i < arguments.length; i++)
 309                                 arguments[i].implicitWidening(inheritedBinding.parameters[i], argumentTypes[i]);
 310
 311                 // Update the anonymous inner class : superclass, interface
 312                 scope.addAnonymousType(anonymousType, (ReferenceBinding) receiverType);
 313                 anonymousType.resolve(scope);
 314                 binding = anonymousType.createsInternalConstructorWithBinding(inheritedBinding);
 315                 return anonymousType.binding; // 1.2 change
 316         }
 317
 318         public String toStringExpression() {
 319                 return this.toStringExpression(0);
 320         }
 321
 322         public String toStringExpression(int tab) {
 323
 324                 String s = ""; //$NON-NLS-1$
 325                 if (enclosingInstance != null)
 326                         s += enclosingInstance.toString() + "."; //$NON-NLS-1$
 327                 s += super.toStringExpression();
 328                 if (anonymousType != null) {
 329                         s += anonymousType.toString(tab);
 330                 } //allows to restart just after the } one line under ....
 331                 return s;
 332         }
 333
 334         public void traverse(IAbstractSyntaxTreeVisitor visitor, BlockScope scope) {
 335
 336                 if (visitor.visit(this, scope)) {
 337                         if (enclosingInstance != null)
 338                                 enclosingInstance.traverse(visitor, scope);
 339                         type.traverse(visitor, scope);
 340                         if (arguments != null) {
 341                                 int argumentsLength = arguments.length;
 342                                 for (int i = 0; i < argumentsLength; i++)
 343                                         arguments[i].traverse(visitor, scope);
 344                         }
 345                         if (anonymousType != null)
 346                                 anonymousType.traverse(visitor, scope);
 347                 }
 348                 visitor.endVisit(this, scope);
 349         }
 350 }