net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/MethodScope.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.lookup;
  12
  13 import net.sourceforge.phpdt.internal.compiler.ast.AbstractMethodDeclaration;
  14 import net.sourceforge.phpdt.internal.compiler.ast.ConstructorDeclaration;
  15 import net.sourceforge.phpdt.internal.compiler.ast.QualifiedNameReference;
  16 import net.sourceforge.phpdt.internal.compiler.ast.SingleNameReference;
  17 import net.sourceforge.phpdt.internal.compiler.ast.TypeDeclaration;
  18 import net.sourceforge.phpdt.internal.compiler.flow.FlowInfo;
  19 import net.sourceforge.phpdt.internal.compiler.flow.UnconditionalFlowInfo;
  20 import net.sourceforge.phpdt.internal.compiler.impl.ReferenceContext;
  21 import net.sourceforge.phpdt.internal.compiler.problem.ProblemReporter;
  22
  23 /**
  24  * Particular block scope used for methods, constructors or clinits,
  25  * representing its outermost blockscope. Note also that such a scope will be
  26  * provided to enclose field initializers subscopes as well.
  27  */
  28 public class MethodScope extends BlockScope {
  29
  30         public ReferenceContext referenceContext;
  31
  32         public boolean isStatic; // method modifier or initializer one
  33
  34         // fields used during name resolution
  35         public static final int NotInFieldDecl = -1; // must be a negative value
  36
  37         public boolean isConstructorCall = false;
  38
  39         public FieldBinding initializedField; // the field being initialized
  40
  41         public int fieldDeclarationIndex = NotInFieldDecl;
  42
  43         // flow analysis
  44         public int analysisIndex; // for setting flow-analysis id
  45
  46         public boolean isPropagatingInnerClassEmulation;
  47
  48         // for local variables table attributes
  49         public int lastIndex = 0;
  50
  51         public long[] definiteInits = new long[4];
  52
  53         public long[][] extraDefiniteInits = new long[4][];
  54
  55         // inner-emulation
  56         public SyntheticArgumentBinding[] extraSyntheticArguments;
  57
  58         public MethodScope(ClassScope parent, ReferenceContext context,
  59                         boolean isStatic) {
  60
  61                 super(METHOD_SCOPE, parent);
  62                 locals = new LocalVariableBinding[5];
  63                 this.referenceContext = context;
  64                 this.isStatic = isStatic;
  65                 this.startIndex = 0;
  66         }
  67
  68         /*
  69          * Spec : 8.4.3 & 9.4
  70          */
  71         private void checkAndSetModifiersForConstructor(MethodBinding methodBinding) {
  72
  73                 int modifiers = methodBinding.modifiers;
  74                 if ((modifiers & AccAlternateModifierProblem) != 0)
  75                         problemReporter().duplicateModifierForMethod(
  76                                         methodBinding.declaringClass,
  77                                         (AbstractMethodDeclaration) referenceContext);
  78
  79                 if (((ConstructorDeclaration) referenceContext).isDefaultConstructor) {
  80                         if (methodBinding.declaringClass.isPublic())
  81                                 modifiers |= AccPublic;
  82                         else if (methodBinding.declaringClass.isProtected())
  83                                 modifiers |= AccProtected;
  84                 }
  85
  86                 // after this point, tests on the 16 bits reserved.
  87                 int realModifiers = modifiers & AccJustFlag;
  88
  89                 // check for abnormal modifiers
  90                 int unexpectedModifiers = ~(AccPublic | AccPrivate | AccProtected);// |
  91                                                                                                                                                         // AccStrictfp);
  92                 if ((realModifiers & unexpectedModifiers) != 0)
  93                         problemReporter().illegalModifierForMethod(
  94                                         methodBinding.declaringClass,
  95                                         (AbstractMethodDeclaration) referenceContext);
  96                 // else if (
  97                 // (((AbstractMethodDeclaration) referenceContext).modifiers &
  98                 // AccStrictfp) != 0)
  99                 // // must check the parse node explicitly
 100                 // problemReporter().illegalModifierForMethod(
 101                 // methodBinding.declaringClass,
 102                 // (AbstractMethodDeclaration) referenceContext);
 103
 104                 // check for incompatible modifiers in the visibility bits, isolate the
 105                 // visibility bits
 106                 int accessorBits = realModifiers
 107                                 & (AccPublic | AccProtected | AccPrivate);
 108                 if ((accessorBits & (accessorBits - 1)) != 0) {
 109                         problemReporter().illegalVisibilityModifierCombinationForMethod(
 110                                         methodBinding.declaringClass,
 111                                         (AbstractMethodDeclaration) referenceContext);
 112
 113                         // need to keep the less restrictive
 114                         if ((accessorBits & AccPublic) != 0) {
 115                                 if ((accessorBits & AccProtected) != 0)
 116                                         modifiers ^= AccProtected;
 117                                 if ((accessorBits & AccPrivate) != 0)
 118                                         modifiers ^= AccPrivate;
 119                         }
 120                         if ((accessorBits & AccProtected) != 0)
 121                                 if ((accessorBits & AccPrivate) != 0)
 122                                         modifiers ^= AccPrivate;
 123                 }
 124
 125                 // if the receiver's declaring class is a private nested type, then make
 126                 // sure the receiver is not private (causes problems for inner type
 127                 // emulation)
 128                 if (methodBinding.declaringClass.isPrivate())
 129                         if ((modifiers & AccPrivate) != 0)
 130                                 modifiers ^= AccPrivate;
 131
 132                 methodBinding.modifiers = modifiers;
 133         }
 134
 135         /*
 136          * Spec : 8.4.3 & 9.4
 137          */
 138         private void checkAndSetModifiersForMethod(MethodBinding methodBinding) {
 139
 140                 int modifiers = methodBinding.modifiers;
 141                 if ((modifiers & AccAlternateModifierProblem) != 0)
 142                         problemReporter().duplicateModifierForMethod(
 143                                         methodBinding.declaringClass,
 144                                         (AbstractMethodDeclaration) referenceContext);
 145
 146                 // after this point, tests on the 16 bits reserved.
 147                 int realModifiers = modifiers & AccJustFlag;
 148
 149                 // set the requested modifiers for a method in an interface
 150                 if (methodBinding.declaringClass.isInterface()) {
 151                         if ((realModifiers & ~(AccPublic | AccAbstract)) != 0)
 152                                 problemReporter().illegalModifierForInterfaceMethod(
 153                                                 methodBinding.declaringClass,
 154                                                 (AbstractMethodDeclaration) referenceContext);
 155                         return;
 156                 }
 157
 158                 // check for abnormal modifiers
 159                 int unexpectedModifiers = ~(AccPublic | AccPrivate | AccProtected
 160                                 | AccAbstract | AccStatic | AccFinal);
 161                 // | AccSynchronized
 162                 // | AccNative
 163                 // | AccStrictfp);
 164                 if ((realModifiers & unexpectedModifiers) != 0)
 165                         problemReporter().illegalModifierForMethod(
 166                                         methodBinding.declaringClass,
 167                                         (AbstractMethodDeclaration) referenceContext);
 168
 169                 // check for incompatible modifiers in the visibility bits, isolate the
 170                 // visibility bits
 171                 int accessorBits = realModifiers
 172                                 & (AccPublic | AccProtected | AccPrivate);
 173                 if ((accessorBits & (accessorBits - 1)) != 0) {
 174                         problemReporter().illegalVisibilityModifierCombinationForMethod(
 175                                         methodBinding.declaringClass,
 176                                         (AbstractMethodDeclaration) referenceContext);
 177
 178                         // need to keep the less restrictive
 179                         if ((accessorBits & AccPublic) != 0) {
 180                                 if ((accessorBits & AccProtected) != 0)
 181                                         modifiers ^= AccProtected;
 182                                 if ((accessorBits & AccPrivate) != 0)
 183                                         modifiers ^= AccPrivate;
 184                         }
 185                         if ((accessorBits & AccProtected) != 0)
 186                                 if ((accessorBits & AccPrivate) != 0)
 187                                         modifiers ^= AccPrivate;
 188                 }
 189
 190                 // check for modifiers incompatible with abstract modifier
 191                 if ((modifiers & AccAbstract) != 0) {
 192                         int incompatibleWithAbstract = AccPrivate | AccStatic | AccFinal;// |
 193                                                                                                                                                                 // AccSynchronized
 194                                                                                                                                                                 // |
 195                                                                                                                                                                 // AccNative
 196                                                                                                                                                                 // |
 197                                                                                                                                                                 // AccStrictfp;
 198                         if ((modifiers & incompatibleWithAbstract) != 0)
 199                                 problemReporter().illegalAbstractModifierCombinationForMethod(
 200                                                 methodBinding.declaringClass,
 201                                                 (AbstractMethodDeclaration) referenceContext);
 202                         if (!methodBinding.declaringClass.isAbstract())
 203                                 problemReporter().abstractMethodInAbstractClass(
 204                                                 (SourceTypeBinding) methodBinding.declaringClass,
 205                                                 (AbstractMethodDeclaration) referenceContext);
 206                 }
 207
 208                 /*
 209                  * DISABLED for backward compatibility with javac (if enabled should
 210                  * also mark private methods as final) // methods from a final class are
 211                  * final : 8.4.3.3 if (methodBinding.declaringClass.isFinal()) modifiers |=
 212                  * AccFinal;
 213                  */
 214                 // native methods cannot also be tagged as strictfp
 215                 // if ((modifiers & AccNative) != 0 && (modifiers & AccStrictfp) != 0)
 216                 // problemReporter().nativeMethodsCannotBeStrictfp(
 217                 // methodBinding.declaringClass,
 218                 // (AbstractMethodDeclaration) referenceContext);
 219                 // static members are only authorized in a static member or top level
 220                 // type
 221                 if (((realModifiers & AccStatic) != 0)
 222                                 && methodBinding.declaringClass.isNestedType()
 223                                 && !methodBinding.declaringClass.isStatic())
 224                         problemReporter().unexpectedStaticModifierForMethod(
 225                                         methodBinding.declaringClass,
 226                                         (AbstractMethodDeclaration) referenceContext);
 227
 228                 methodBinding.modifiers = modifiers;
 229         }
 230
 231         /*
 232          * Compute variable positions in scopes given an initial position offset
 233          * ignoring unused local variables.
 234          *
 235          * Deal with arguments here, locals and subscopes are processed in
 236          * BlockScope method
 237          */
 238         // public void computeLocalVariablePositions(int initOffset, CodeStream
 239         // codeStream) {
 240         //
 241         // boolean isReportingUnusedArgument = false;
 242         //
 243         // if (referenceContext instanceof AbstractMethodDeclaration) {
 244         // AbstractMethodDeclaration methodDecl =
 245         // (AbstractMethodDeclaration)referenceContext;
 246         // MethodBinding method = methodDecl.binding;
 247         // CompilerOptions options = compilationUnitScope().environment.options;
 248         // if (!(method.isAbstract()
 249         // || (method.isImplementing() &&
 250         // !options.reportUnusedParameterWhenImplementingAbstract)
 251         // || (method.isOverriding() && !method.isImplementing() &&
 252         // !options.reportUnusedParameterWhenOverridingConcrete)
 253         // || method.isMain())) {
 254         // isReportingUnusedArgument = true;
 255         // }
 256         // }
 257         // this.offset = initOffset;
 258         // this.maxOffset = initOffset;
 259         //
 260         // // manage arguments
 261         // int ilocal = 0, maxLocals = this.localIndex;
 262         // while (ilocal < maxLocals) {
 263         // LocalVariableBinding local = locals[ilocal];
 264         // if (local == null || !local.isArgument) break; // done with arguments
 265         //
 266         // // do not report fake used variable
 267         // if (isReportingUnusedArgument
 268         // && local.useFlag == LocalVariableBinding.UNUSED
 269         // && ((local.declaration.bits & ASTNode.IsLocalDeclarationReachableMASK) !=
 270         // 0)) { // declaration is reachable
 271         // this.problemReporter().unusedArgument(local.declaration);
 272         // }
 273         //
 274         // // record user-defined argument for attribute generation
 275         // codeStream.record(local);
 276         //
 277         // // assign variable position
 278         // local.resolvedPosition = this.offset;
 279         //
 280         // if ((local.type == LongBinding) || (local.type == DoubleBinding)) {
 281         // this.offset += 2;
 282         // } else {
 283         // this.offset++;
 284         // }
 285         // // check for too many arguments/local variables
 286         // if (this.offset > 0xFF) { // no more than 255 words of arguments
 287         // this.problemReporter().noMoreAvailableSpaceForArgument(local,
 288         // local.declaration);
 289         // }
 290         // ilocal++;
 291         // }
 292         //
 293         // // sneak in extra argument before other local variables
 294         // if (extraSyntheticArguments != null) {
 295         // for (int iarg = 0, maxArguments = extraSyntheticArguments.length; iarg <
 296         // maxArguments; iarg++){
 297         // SyntheticArgumentBinding argument = extraSyntheticArguments[iarg];
 298         // argument.resolvedPosition = this.offset;
 299         // if ((argument.type == LongBinding) || (argument.type == DoubleBinding)){
 300         // this.offset += 2;
 301         // } else {
 302         // this.offset++;
 303         // }
 304         // if (this.offset > 0xFF) { // no more than 255 words of arguments
 305         // this.problemReporter().noMoreAvailableSpaceForArgument(argument,
 306         // (ASTNode)this.referenceContext);
 307         // }
 308         // }
 309         // }
 310         // this.computeLocalVariablePositions(ilocal, this.offset, codeStream);
 311         // }
 312         /*
 313          * Error management: keep null for all the errors that prevent the method to
 314          * be created otherwise return a correct method binding (but without the
 315          * element that caused the problem) : ie : Incorrect thrown exception
 316          */
 317         MethodBinding createMethod(AbstractMethodDeclaration method) {
 318
 319                 // is necessary to ensure error reporting
 320                 this.referenceContext = method;
 321                 method.scope = this;
 322                 SourceTypeBinding declaringClass = referenceType().binding;
 323                 int modifiers = method.modifiers | AccUnresolved;
 324                 if (method.isConstructor()) {
 325                         method.binding = new MethodBinding(modifiers, null, null,
 326                                         declaringClass);
 327                         checkAndSetModifiersForConstructor(method.binding);
 328                 } else {
 329                         if (declaringClass.isInterface())
 330                                 modifiers |= AccPublic | AccAbstract;
 331                         method.binding = new MethodBinding(modifiers, method.selector,
 332                                         null, null, null, declaringClass);
 333                         checkAndSetModifiersForMethod(method.binding);
 334                 }
 335
 336                 this.isStatic = method.binding.isStatic();
 337                 return method.binding;
 338         }
 339
 340         /*
 341          * Overridden to detect the error case inside an explicit constructor call:
 342          *
 343          * class X { int i; X myX; X(X x) { this(i, myX.i, x.i); // same for super
 344          * calls... only the first 2 field accesses are errors } }
 345          */
 346         public FieldBinding findField(TypeBinding receiverType, char[] fieldName,
 347                         InvocationSite invocationSite) {
 348
 349                 FieldBinding field = super.findField(receiverType, fieldName,
 350                                 invocationSite);
 351                 if (field == null)
 352                         return null;
 353                 if (!field.isValidBinding())
 354                         return field; // answer the error field
 355                 if (field.isStatic())
 356                         return field; // static fields are always accessible
 357
 358                 if (!isConstructorCall || receiverType != enclosingSourceType())
 359                         return field;
 360
 361                 if (invocationSite instanceof SingleNameReference)
 362                         return new ProblemFieldBinding(field.declaringClass, fieldName,
 363                                         NonStaticReferenceInConstructorInvocation);
 364                 if (invocationSite instanceof QualifiedNameReference) {
 365                         // look to see if the field is the first binding
 366                         QualifiedNameReference name = (QualifiedNameReference) invocationSite;
 367                         if (name.binding == null)
 368                                 // only true when the field is the fieldbinding at the beginning
 369                                 // of name's tokens
 370                                 return new ProblemFieldBinding(field.declaringClass, fieldName,
 371                                                 NonStaticReferenceInConstructorInvocation);
 372                 }
 373                 return field;
 374         }
 375
 376         public boolean isInsideInitializer() {
 377
 378                 return (referenceContext instanceof TypeDeclaration);
 379         }
 380
 381         public boolean isInsideInitializerOrConstructor() {
 382
 383                 return (referenceContext instanceof TypeDeclaration)
 384                                 || (referenceContext instanceof ConstructorDeclaration);
 385         }
 386
 387         /*
 388          * Answer the problem reporter to use for raising new problems.
 389          *
 390          * Note that as a side-effect, this updates the current reference context
 391          * (unit, type or method) in case the problem handler decides it is
 392          * necessary to abort.
 393          */
 394         public ProblemReporter problemReporter() {
 395
 396                 MethodScope outerMethodScope;
 397                 if ((outerMethodScope = outerMostMethodScope()) == this) {
 398                         ProblemReporter problemReporter = referenceCompilationUnit().problemReporter;
 399                         problemReporter.referenceContext = referenceContext;
 400                         return problemReporter;
 401                 } else {
 402                         return outerMethodScope.problemReporter();
 403                 }
 404         }
 405
 406         public final int recordInitializationStates(FlowInfo flowInfo) {
 407
 408                 if (!flowInfo.isReachable())
 409                         return -1;
 410
 411                 UnconditionalFlowInfo unconditionalFlowInfo = flowInfo
 412                                 .unconditionalInits();
 413                 long[] extraInits = unconditionalFlowInfo.extraDefiniteInits;
 414                 long inits = unconditionalFlowInfo.definiteInits;
 415                 checkNextEntry: for (int i = lastIndex; --i >= 0;) {
 416                         if (definiteInits[i] == inits) {
 417                                 long[] otherInits = extraDefiniteInits[i];
 418                                 if ((extraInits != null) && (otherInits != null)) {
 419                                         if (extraInits.length == otherInits.length) {
 420                                                 int j, max;
 421                                                 for (j = 0, max = extraInits.length; j < max; j++) {
 422                                                         if (extraInits[j] != otherInits[j]) {
 423                                                                 continue checkNextEntry;
 424                                                         }
 425                                                 }
 426                                                 return i;
 427                                         }
 428                                 } else {
 429                                         if ((extraInits == null) && (otherInits == null)) {
 430                                                 return i;
 431                                         }
 432                                 }
 433                         }
 434                 }
 435
 436                 // add a new entry
 437                 if (definiteInits.length == lastIndex) {
 438                         // need a resize
 439                         System.arraycopy(definiteInits, 0,
 440                                         (definiteInits = new long[lastIndex + 20]), 0, lastIndex);
 441                         System.arraycopy(extraDefiniteInits, 0,
 442                                         (extraDefiniteInits = new long[lastIndex + 20][]), 0,
 443                                         lastIndex);
 444                 }
 445                 definiteInits[lastIndex] = inits;
 446                 if (extraInits != null) {
 447                         extraDefiniteInits[lastIndex] = new long[extraInits.length];
 448                         System.arraycopy(extraInits, 0, extraDefiniteInits[lastIndex], 0,
 449                                         extraInits.length);
 450                 }
 451                 return lastIndex++;
 452         }
 453
 454         /*
 455          * Answer the reference type of this scope.
 456          *
 457          * It is the nearest enclosing type of this scope.
 458          */
 459         public TypeDeclaration referenceType() {
 460
 461                 return (TypeDeclaration) ((ClassScope) parent).referenceContext;
 462         }
 463
 464         String basicToString(int tab) {
 465
 466                 String newLine = "\n"; //$NON-NLS-1$
 467                 for (int i = tab; --i >= 0;)
 468                         newLine += "\t"; //$NON-NLS-1$
 469
 470                 String s = newLine + "--- Method Scope ---"; //$NON-NLS-1$
 471                 newLine += "\t"; //$NON-NLS-1$
 472                 s += newLine + "locals:"; //$NON-NLS-1$
 473                 for (int i = 0; i < localIndex; i++)
 474                         s += newLine + "\t" + locals[i].toString(); //$NON-NLS-1$
 475                 s += newLine + "startIndex = " + startIndex; //$NON-NLS-1$
 476                 s += newLine + "isConstructorCall = " + isConstructorCall; //$NON-NLS-1$
 477                 s += newLine + "initializedField = " + initializedField; //$NON-NLS-1$
 478                 s += newLine + "fieldDeclarationIndex = " + fieldDeclarationIndex; //$NON-NLS-1$
 479                 s += newLine + "referenceContext = " + referenceContext; //$NON-NLS-1$
 480                 return s;
 481         }
 482
 483 }