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