net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/lookup/MethodScope.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v0.5
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v05.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, representing
  25  * its outermost blockscope. Note also that such a scope will be provided to enclose
  26  * field initializers subscopes as well.
  27  */
  28 public class MethodScope extends BlockScope {
  29
  30         public ReferenceContext referenceContext;
  31         public boolean needToCompactLocalVariables;
  32         public boolean isStatic; // method modifier or initializer one
  33
  34         //fields used in the TC process (no real meaning)
  35         public static final int NotInFieldDecl = -1; //must be a negative value
  36         public boolean isConstructorCall = false; //modified on the fly by the TC
  37         public int fieldDeclarationIndex = NotInFieldDecl;
  38         //modified on the fly by the TC
  39
  40         public int analysisIndex; // for setting flow-analysis id
  41
  42         public boolean isPropagatingInnerClassEmulation;
  43
  44         // for local variables table attributes
  45         public int lastIndex = 0;
  46         public long[] definiteInits = new long[4];
  47         public long[][] extraDefiniteInits = new long[4][];
  48
  49         public MethodScope(
  50                 ClassScope parent,
  51                 ReferenceContext context,
  52                 boolean isStatic) {
  53
  54                 super(METHOD_SCOPE, parent);
  55                 locals = new LocalVariableBinding[5];
  56                 this.referenceContext = context;
  57                 this.isStatic = isStatic;
  58                 this.startIndex = 0;
  59         }
  60
  61         /* Spec : 8.4.3 & 9.4
  62          */
  63         private void checkAndSetModifiersForConstructor(MethodBinding methodBinding) {
  64
  65                 int modifiers = methodBinding.modifiers;
  66                 if ((modifiers & AccAlternateModifierProblem) != 0)
  67                         problemReporter().duplicateModifierForMethod(
  68                                 methodBinding.declaringClass,
  69                                 (AbstractMethodDeclaration) referenceContext);
  70
  71                 if (((ConstructorDeclaration) referenceContext).isDefaultConstructor) {
  72                         if (methodBinding.declaringClass.isPublic())
  73                                 modifiers |= AccPublic;
  74                         else if (methodBinding.declaringClass.isProtected())
  75                                 modifiers |= AccProtected;
  76                 }
  77
  78                 // after this point, tests on the 16 bits reserved.
  79                 int realModifiers = modifiers & AccJustFlag;
  80
  81                 // check for abnormal modifiers
  82                 int unexpectedModifiers =
  83                         ~(AccPublic | AccPrivate | AccProtected | AccStrictfp);
  84                 if ((realModifiers & unexpectedModifiers) != 0)
  85                         problemReporter().illegalModifierForMethod(
  86                                 methodBinding.declaringClass,
  87                                 (AbstractMethodDeclaration) referenceContext);
  88                 else if (
  89                         (((AbstractMethodDeclaration) referenceContext).modifiers & AccStrictfp) != 0)
  90                         // must check the parse node explicitly
  91                         problemReporter().illegalModifierForMethod(
  92                                 methodBinding.declaringClass,
  93                                 (AbstractMethodDeclaration) referenceContext);
  94
  95                 // check for incompatible modifiers in the visibility bits, isolate the visibility bits
  96                 int accessorBits = realModifiers & (AccPublic | AccProtected | AccPrivate);
  97                 if ((accessorBits & (accessorBits - 1)) != 0) {
  98                         problemReporter().illegalVisibilityModifierCombinationForMethod(
  99                                 methodBinding.declaringClass,
 100                                 (AbstractMethodDeclaration) referenceContext);
 101
 102                         // need to keep the less restrictive
 103                         if ((accessorBits & AccPublic) != 0) {
 104                                 if ((accessorBits & AccProtected) != 0)
 105                                         modifiers ^= AccProtected;
 106                                 if ((accessorBits & AccPrivate) != 0)
 107                                         modifiers ^= AccPrivate;
 108                         }
 109                         if ((accessorBits & AccProtected) != 0)
 110                                 if ((accessorBits & AccPrivate) != 0)
 111                                         modifiers ^= AccPrivate;
 112                 }
 113
 114                 // 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)
 115                 if (methodBinding.declaringClass.isPrivate())
 116                         if ((modifiers & AccPrivate) != 0)
 117                                 modifiers ^= AccPrivate;
 118
 119                 methodBinding.modifiers = modifiers;
 120         }
 121
 122         /* Spec : 8.4.3 & 9.4
 123          */
 124         private void checkAndSetModifiersForMethod(MethodBinding methodBinding) {
 125
 126                 int modifiers = methodBinding.modifiers;
 127                 if ((modifiers & AccAlternateModifierProblem) != 0)
 128                         problemReporter().duplicateModifierForMethod(
 129                                 methodBinding.declaringClass,
 130                                 (AbstractMethodDeclaration) referenceContext);
 131
 132                 // after this point, tests on the 16 bits reserved.
 133                 int realModifiers = modifiers & AccJustFlag;
 134
 135                 // set the requested modifiers for a method in an interface
 136                 if (methodBinding.declaringClass.isInterface()) {
 137                         if ((realModifiers & ~(AccPublic | AccAbstract)) != 0)
 138                                 problemReporter().illegalModifierForInterfaceMethod(
 139                                         methodBinding.declaringClass,
 140                                         (AbstractMethodDeclaration) referenceContext);
 141                         return;
 142                 }
 143
 144                 // check for abnormal modifiers
 145                 int unexpectedModifiers =
 146                         ~(
 147                                 AccPublic
 148                                         | AccPrivate
 149                                         | AccProtected
 150                                         | AccAbstract
 151                                         | AccStatic
 152                                         | AccFinal
 153                                         | AccSynchronized
 154                                         | AccNative
 155                                         | AccStrictfp);
 156                 if ((realModifiers & unexpectedModifiers) != 0)
 157                         problemReporter().illegalModifierForMethod(
 158                                 methodBinding.declaringClass,
 159                                 (AbstractMethodDeclaration) referenceContext);
 160
 161                 // check for incompatible modifiers in the visibility bits, isolate the visibility bits
 162                 int accessorBits = realModifiers & (AccPublic | AccProtected | AccPrivate);
 163                 if ((accessorBits & (accessorBits - 1)) != 0) {
 164                         problemReporter().illegalVisibilityModifierCombinationForMethod(
 165                                 methodBinding.declaringClass,
 166                                 (AbstractMethodDeclaration) referenceContext);
 167
 168                         // need to keep the less restrictive
 169                         if ((accessorBits & AccPublic) != 0) {
 170                                 if ((accessorBits & AccProtected) != 0)
 171                                         modifiers ^= AccProtected;
 172                                 if ((accessorBits & AccPrivate) != 0)
 173                                         modifiers ^= AccPrivate;
 174                         }
 175                         if ((accessorBits & AccProtected) != 0)
 176                                 if ((accessorBits & AccPrivate) != 0)
 177                                         modifiers ^= AccPrivate;
 178                 }
 179
 180                 // check for modifiers incompatible with abstract modifier
 181                 if ((modifiers & AccAbstract) != 0) {
 182                         int incompatibleWithAbstract =
 183                                 AccPrivate | AccStatic | AccFinal | AccSynchronized | AccNative | AccStrictfp;
 184                         if ((modifiers & incompatibleWithAbstract) != 0)
 185                                 problemReporter().illegalAbstractModifierCombinationForMethod(
 186                                         methodBinding.declaringClass,
 187                                         (AbstractMethodDeclaration) referenceContext);
 188                         if (!methodBinding.declaringClass.isAbstract())
 189                                 problemReporter().abstractMethodInAbstractClass(
 190                                         (SourceTypeBinding) methodBinding.declaringClass,
 191                                         (AbstractMethodDeclaration) referenceContext);
 192                 }
 193
 194                 /* DISABLED for backward compatibility with javac (if enabled should also mark private methods as final)
 195                 // methods from a final class are final : 8.4.3.3
 196                 if (methodBinding.declaringClass.isFinal())
 197                         modifiers |= AccFinal;
 198                 */
 199                 // native methods cannot also be tagged as strictfp
 200                 if ((modifiers & AccNative) != 0 && (modifiers & AccStrictfp) != 0)
 201                         problemReporter().nativeMethodsCannotBeStrictfp(
 202                                 methodBinding.declaringClass,
 203                                 (AbstractMethodDeclaration) referenceContext);
 204
 205                 // static members are only authorized in a static member or top level type
 206                 if (((realModifiers & AccStatic) != 0)
 207                         && methodBinding.declaringClass.isNestedType()
 208                         && !methodBinding.declaringClass.isStatic())
 209                         problemReporter().unexpectedStaticModifierForMethod(
 210                                 methodBinding.declaringClass,
 211                                 (AbstractMethodDeclaration) referenceContext);
 212
 213                 methodBinding.modifiers = modifiers;
 214         }
 215
 216         /* Error management:
 217          *              keep null for all the errors that prevent the method to be created
 218          *              otherwise return a correct method binding (but without the element
 219          *              that caused the problem) : ie : Incorrect thrown exception
 220          */
 221         MethodBinding createMethod(AbstractMethodDeclaration method) {
 222
 223                 // is necessary to ensure error reporting
 224                 this.referenceContext = method;
 225                 method.scope = this;
 226                 SourceTypeBinding declaringClass = referenceType().binding;
 227                 int modifiers = method.modifiers | AccUnresolved;
 228                 if (method.isConstructor()) {
 229                         method.binding = new MethodBinding(modifiers, null, null, declaringClass);
 230                         checkAndSetModifiersForConstructor(method.binding);
 231                 } else {
 232                         if (declaringClass.isInterface())
 233                                 modifiers |= AccPublic | AccAbstract;
 234                         method.binding =
 235                                 new MethodBinding(modifiers, method.selector, null, null, null, declaringClass);
 236                         checkAndSetModifiersForMethod(method.binding);
 237                 }
 238
 239                 this.isStatic = method.binding.isStatic();
 240                 return method.binding;
 241         }
 242
 243         /* Overridden to detect the error case inside an explicit constructor call:
 244
 245         class X {
 246                 int i;
 247                 X myX;
 248                 X(X x) {
 249                         this(i, myX.i, x.i); // same for super calls... only the first 2 field accesses are errors
 250                 }
 251         }
 252         */
 253         public FieldBinding findField(
 254                 TypeBinding receiverType,
 255                 char[] fieldName,
 256                 InvocationSite invocationSite) {
 257
 258                 FieldBinding field = super.findField(receiverType, fieldName, invocationSite);
 259                 if (field == null)
 260                         return null;
 261                 if (!field.isValidBinding())
 262                         return field; // answer the error field
 263                 if (field.isStatic())
 264                         return field; // static fields are always accessible
 265
 266                 if (!isConstructorCall || receiverType != enclosingSourceType())
 267                         return field;
 268
 269                 if (invocationSite instanceof SingleNameReference)
 270                         return new ProblemFieldBinding(
 271                                 field.declaringClass,
 272                                 fieldName,
 273                                 NonStaticReferenceInConstructorInvocation);
 274                 if (invocationSite instanceof QualifiedNameReference) {
 275                         // look to see if the field is the first binding
 276                         QualifiedNameReference name = (QualifiedNameReference) invocationSite;
 277                         if (name.binding == null)
 278                                 // only true when the field is the fieldbinding at the beginning of name's tokens
 279                                 return new ProblemFieldBinding(
 280                                         field.declaringClass,
 281                                         fieldName,
 282                                         NonStaticReferenceInConstructorInvocation);
 283                 }
 284                 return field;
 285         }
 286
 287         public boolean isInsideInitializer() {
 288
 289                 return (referenceContext instanceof TypeDeclaration);
 290         }
 291
 292         public boolean isInsideInitializerOrConstructor() {
 293
 294                 return (referenceContext instanceof TypeDeclaration)
 295                         || (referenceContext instanceof ConstructorDeclaration);
 296         }
 297
 298         /* Answer the problem reporter to use for raising new problems.
 299          *
 300          * Note that as a side-effect, this updates the current reference context
 301          * (unit, type or method) in case the problem handler decides it is necessary
 302          * to abort.
 303          */
 304         public ProblemReporter problemReporter() {
 305
 306                 MethodScope outerMethodScope;
 307                 if ((outerMethodScope = outerMostMethodScope()) == this) {
 308                         ProblemReporter problemReporter = referenceCompilationUnit().problemReporter;
 309                         problemReporter.referenceContext = referenceContext;
 310                         return problemReporter;
 311                 } else {
 312                         return outerMethodScope.problemReporter();
 313                 }
 314         }
 315
 316         public final int recordInitializationStates(FlowInfo flowInfo) {
 317
 318                 if ((flowInfo == FlowInfo.DeadEnd) || (flowInfo.isFakeReachable())) {
 319                         return -1;
 320                 }
 321                 UnconditionalFlowInfo unconditionalFlowInfo = flowInfo.unconditionalInits();
 322                 long[] extraInits = unconditionalFlowInfo.extraDefiniteInits;
 323                 long inits = unconditionalFlowInfo.definiteInits;
 324                 checkNextEntry : for (int i = lastIndex; --i >= 0;) {
 325                         if (definiteInits[i] == inits) {
 326                                 long[] otherInits = extraDefiniteInits[i];
 327                                 if ((extraInits != null) && (otherInits != null)) {
 328                                         if (extraInits.length == otherInits.length) {
 329                                                 int j, max;
 330                                                 for (j = 0, max = extraInits.length; j < max; j++) {
 331                                                         if (extraInits[j] != otherInits[j]) {
 332                                                                 continue checkNextEntry;
 333                                                         }
 334                                                 }
 335                                                 return i;
 336                                         }
 337                                 } else {
 338                                         if ((extraInits == null) && (otherInits == null)) {
 339                                                 return i;
 340                                         }
 341                                 }
 342                         }
 343                 }
 344
 345                 // add a new entry
 346                 if (definiteInits.length == lastIndex) {
 347                         // need a resize
 348                         System.arraycopy(
 349                                 definiteInits,
 350                                 0,
 351                                 (definiteInits = new long[lastIndex + 20]),
 352                                 0,
 353                                 lastIndex);
 354                         System.arraycopy(
 355                                 extraDefiniteInits,
 356                                 0,
 357                                 (extraDefiniteInits = new long[lastIndex + 20][]),
 358                                 0,
 359                                 lastIndex);
 360                 }
 361                 definiteInits[lastIndex] = inits;
 362                 if (extraInits != null) {
 363                         extraDefiniteInits[lastIndex] = new long[extraInits.length];
 364                         System.arraycopy(
 365                                 extraInits,
 366                                 0,
 367                                 extraDefiniteInits[lastIndex],
 368                                 0,
 369                                 extraInits.length);
 370                 }
 371                 return lastIndex++;
 372         }
 373
 374         /* Answer the reference type of this scope.
 375         *
 376         * i.e. the nearest enclosing type of this scope.
 377         */
 378         public TypeDeclaration referenceType() {
 379
 380                 return (TypeDeclaration) ((ClassScope) parent).referenceContext;
 381         }
 382
 383         String basicToString(int tab) {
 384
 385                 String newLine = "\n"; //$NON-NLS-1$
 386                 for (int i = tab; --i >= 0;)
 387                         newLine += "\t"; //$NON-NLS-1$
 388
 389                 String s = newLine + "--- Method Scope ---"; //$NON-NLS-1$
 390                 newLine += "\t"; //$NON-NLS-1$
 391                 s += newLine + "locals:"; //$NON-NLS-1$
 392                 for (int i = 0; i < localIndex; i++)
 393                         s += newLine + "\t" + locals[i].toString(); //$NON-NLS-1$
 394                 s += newLine + "startIndex = " + startIndex; //$NON-NLS-1$
 395                 s += newLine + "isConstructorCall = " + isConstructorCall; //$NON-NLS-1$
 396                 s += newLine + "fieldDeclarationIndex = " + fieldDeclarationIndex; //$NON-NLS-1$
 397                 return s;
 398         }
 399
 400 }