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