net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/compiler/ast/Annotation.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2008 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-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.core.compiler.CharOperation;
  14 import net.sourceforge.phpdt.internal.compiler.ASTVisitor;
  15 import net.sourceforge.phpdt.internal.compiler.classfmt.ClassFileConstants;
  16 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
  17 import net.sourceforge.phpdt.internal.compiler.impl.Constant;
  18 import net.sourceforge.phpdt.internal.compiler.lookup.*;
  19
  20 /**
  21  * Annotation
  22  */
  23 public abstract class Annotation extends Expression {
  24
  25         final static MemberValuePair[] NoValuePairs = new MemberValuePair[0];
  26         public int declarationSourceEnd;
  27         public Binding recipient;
  28
  29         public TypeReference type;
  30         /**
  31          *  The representation of this annotation in the type system.
  32          */
  33         private AnnotationBinding compilerAnnotation = null;
  34
  35         public static long getRetentionPolicy(char[] policyName) {
  36                 if (policyName == null || policyName.length == 0)
  37                         return 0;
  38                 switch(policyName[0]) {
  39                         case 'C' :
  40                                 if (CharOperation.equals(policyName, TypeConstants.UPPER_CLASS))
  41                                         return TagBits.AnnotationClassRetention;
  42                                 break;
  43                         case 'S' :
  44                                 if (CharOperation.equals(policyName, TypeConstants.UPPER_SOURCE))
  45                                         return TagBits.AnnotationSourceRetention;
  46                                 break;
  47                         case 'R' :
  48                                 if (CharOperation.equals(policyName, TypeConstants.UPPER_RUNTIME))
  49                                         return TagBits.AnnotationRuntimeRetention;
  50                                 break;
  51                 }
  52                 return 0; // unknown
  53         }
  54
  55         public static long getTargetElementType(char[] elementName) {
  56                 if (elementName == null || elementName.length == 0)
  57                         return 0;
  58                 switch(elementName[0]) {
  59                         case 'A' :
  60                                 if (CharOperation.equals(elementName, TypeConstants.UPPER_ANNOTATION_TYPE))
  61                                         return TagBits.AnnotationForAnnotationType;
  62                                 break;
  63                         case 'C' :
  64                                 if (CharOperation.equals(elementName, TypeConstants.UPPER_CONSTRUCTOR))
  65                                         return TagBits.AnnotationForConstructor;
  66                                 break;
  67                         case 'F' :
  68                                 if (CharOperation.equals(elementName, TypeConstants.UPPER_FIELD))
  69                                         return TagBits.AnnotationForField;
  70                                 break;
  71                         case 'L' :
  72                                 if (CharOperation.equals(elementName, TypeConstants.UPPER_LOCAL_VARIABLE))
  73                                         return TagBits.AnnotationForLocalVariable;
  74                                 break;
  75                         case 'M' :
  76                                 if (CharOperation.equals(elementName, TypeConstants.UPPER_METHOD))
  77                                         return TagBits.AnnotationForMethod;
  78                                 break;
  79                         case 'P' :
  80                                 if (CharOperation.equals(elementName, TypeConstants.UPPER_PARAMETER))
  81                                         return TagBits.AnnotationForParameter;
  82                                 else if (CharOperation.equals(elementName, TypeConstants.UPPER_PACKAGE))
  83                                         return TagBits.AnnotationForPackage;
  84                                 break;
  85                         case 'T' :
  86                                 if (CharOperation.equals(elementName, TypeConstants.TYPE))
  87                                         return TagBits.AnnotationForType;
  88                                 break;
  89                 }
  90                 return 0; // unknown
  91         }
  92
  93         public ElementValuePair[] computeElementValuePairs() {
  94                 return Binding.NO_ELEMENT_VALUE_PAIRS;
  95         }
  96
  97         /**
  98          * Compute the bit pattern for recognized standard annotations the compiler may need to act upon
  99          */
 100         private long detectStandardAnnotation(Scope scope, ReferenceBinding annotationType, MemberValuePair valueAttribute) {
 101                 long tagBits = 0;
 102                 switch (annotationType.id) {
 103                         // retention annotation
 104                         case TypeIds.T_JavaLangAnnotationRetention :
 105                                 if (valueAttribute != null) {
 106                                         Expression expr = valueAttribute.value;
 107                                         if ((expr.bits & Binding.VARIABLE) == Binding.FIELD) {
 108                                                 FieldBinding field = ((Reference)expr).fieldBinding();
 109                                                 if (field != null && field.declaringClass.id == T_JavaLangAnnotationRetentionPolicy) {
 110                                                         tagBits |= getRetentionPolicy(field.name);
 111                                                 }
 112                                         }
 113                                 }
 114                                 break;
 115                         // target annotation
 116                         case TypeIds.T_JavaLangAnnotationTarget :
 117                                 tagBits |= TagBits.AnnotationTarget; // target specified (could be empty)
 118                                 if (valueAttribute != null) {
 119                                         Expression expr = valueAttribute.value;
 120                                         if (expr instanceof ArrayInitializer) {
 121                                                 ArrayInitializer initializer = (ArrayInitializer) expr;
 122                                                 final Expression[] expressions = initializer.expressions;
 123                                                 if (expressions != null) {
 124                                                         for (int i = 0, length = expressions.length; i < length; i++) {
 125                                                                 Expression initExpr = expressions[i];
 126                                                                 if ((initExpr.bits & Binding.VARIABLE) == Binding.FIELD) {
 127                                                                         FieldBinding field = ((Reference) initExpr).fieldBinding();
 128                                                                         if (field != null && field.declaringClass.id == T_JavaLangAnnotationElementType) {
 129                                                                                 long element = getTargetElementType(field.name);
 130                                                                                 if ((tagBits & element) != 0) {
 131                                                                                         scope.problemReporter().duplicateTargetInTargetAnnotation(annotationType, (NameReference)initExpr);
 132                                                                                 } else {
 133                                                                                         tagBits |= element;
 134                                                                                 }
 135                                                                         }
 136                                                                 }
 137                                                         }
 138                                                 }
 139                                         } else if ((expr.bits & Binding.VARIABLE) == Binding.FIELD) {
 140                                                 FieldBinding field = ((Reference) expr).fieldBinding();
 141                                                 if (field != null && field.declaringClass.id == T_JavaLangAnnotationElementType) {
 142                                                         tagBits |= getTargetElementType(field.name);
 143                                                 }
 144                                         }
 145                                 }
 146                                 break;
 147                         // marker annotations
 148                         case TypeIds.T_JavaLangDeprecated :
 149                                 tagBits |= TagBits.AnnotationDeprecated;
 150                                 break;
 151                         case TypeIds.T_JavaLangAnnotationDocumented :
 152                                 tagBits |= TagBits.AnnotationDocumented;
 153                                 break;
 154                         case TypeIds.T_JavaLangAnnotationInherited :
 155                                 tagBits |= TagBits.AnnotationInherited;
 156                                 break;
 157                         case TypeIds.T_JavaLangOverride :
 158                                 tagBits |= TagBits.AnnotationOverride;
 159                                 break;
 160                         case TypeIds.T_JavaLangSuppressWarnings :
 161                                 tagBits |= TagBits.AnnotationSuppressWarnings;
 162                                 break;
 163                 }
 164                 return tagBits;
 165         }
 166
 167         public AnnotationBinding getCompilerAnnotation() {
 168                 return this.compilerAnnotation;
 169         }
 170
 171         public abstract MemberValuePair[] memberValuePairs();
 172
 173         public StringBuffer printExpression(int indent, StringBuffer output) {
 174                 output.append('@');
 175                 this.type.printExpression(0, output);
 176                 return output;
 177         }
 178
 179         public void recordSuppressWarnings(Scope scope, int startSuppresss, int endSuppress, boolean isSuppressingWarnings) {
 180                 long suppressWarningIrritants = 0;
 181                 MemberValuePair[] pairs = this.memberValuePairs();
 182                 pairLoop: for (int i = 0, length = pairs.length; i < length; i++) {
 183                         MemberValuePair pair = pairs[i];
 184                         if (CharOperation.equals(pair.name, TypeConstants.VALUE)) {
 185                                 Expression value = pair.value;
 186                                 if (value instanceof ArrayInitializer) {
 187                                         ArrayInitializer initializer = (ArrayInitializer) value;
 188                                         Expression[] inits = initializer.expressions;
 189                                         if (inits != null) {
 190                                                 for (int j = 0, initsLength = inits.length; j < initsLength; j++) {
 191                                                         Constant cst = inits[j].constant;
 192                                                         if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {
 193                                                                 long irritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
 194                                                                 if (irritants != 0) {
 195                                                                         if ((suppressWarningIrritants & irritants) == irritants) {
 196                                                                                 scope.problemReporter().unusedWarningToken(inits[j]);
 197                                                                         } else {
 198                                                                                 suppressWarningIrritants |= irritants;
 199                                                                         }
 200                                                                 } else {
 201                                                                         scope.problemReporter().unhandledWarningToken(inits[j]);
 202                                                                 }
 203                                                         }
 204                                                 }
 205                                         }
 206                                 } else {
 207                                         Constant cst = value.constant;
 208                                         if (cst != Constant.NotAConstant && cst.typeID() == T_JavaLangString) {
 209                                                 long irritants = CompilerOptions.warningTokenToIrritants(cst.stringValue());
 210                                                 if (irritants != 0) {
 211                                                         suppressWarningIrritants |= irritants;
 212                                                 } else {
 213                                                         scope.problemReporter().unhandledWarningToken(value);
 214                                                 }
 215                                         }
 216                                 }
 217                                 break pairLoop;
 218                         }
 219                 }
 220                 if (isSuppressingWarnings && suppressWarningIrritants != 0) {
 221                         scope.referenceCompilationUnit().recordSuppressWarnings(suppressWarningIrritants, this, startSuppresss, endSuppress);
 222                 }
 223         }
 224
 225         public TypeBinding resolveType(BlockScope scope) {
 226
 227                 if (this.compilerAnnotation != null)
 228                         return this.resolvedType;
 229                 this.constant = Constant.NotAConstant;
 230
 231                 TypeBinding typeBinding = this.type.resolveType(scope);
 232                 if (typeBinding == null) {
 233                         return null;
 234                 }
 235                 this.resolvedType = typeBinding;
 236                 // ensure type refers to an annotation type
 237                 if (!typeBinding.isAnnotationType() && typeBinding.isValidBinding()) {
 238                         scope.problemReporter().typeMismatchError(typeBinding, scope.getJavaLangAnnotationAnnotation(), this.type, null);
 239                         return null;
 240                 }
 241
 242                 ReferenceBinding annotationType = (ReferenceBinding) this.resolvedType;
 243                 MethodBinding[] methods = annotationType.methods();
 244                 // clone valuePairs to keep track of unused ones
 245                 MemberValuePair[] originalValuePairs = memberValuePairs();
 246                 MemberValuePair valueAttribute = null; // remember the first 'value' pair
 247                 MemberValuePair[] pairs;
 248                 int pairsLength = originalValuePairs.length;
 249                 if (pairsLength > 0) {
 250                         System.arraycopy(originalValuePairs, 0, pairs = new MemberValuePair[pairsLength], 0, pairsLength);
 251                 } else {
 252                         pairs = originalValuePairs;
 253                 }
 254
 255                 nextMember: for (int i = 0, requiredLength = methods.length; i < requiredLength; i++) {
 256                         MethodBinding method = methods[i];
 257                         char[] selector = method.selector;
 258                         boolean foundValue = false;
 259                         nextPair: for (int j = 0; j < pairsLength; j++) {
 260                                 MemberValuePair pair = pairs[j];
 261                                 if (pair == null) continue nextPair;
 262                                 char[] name = pair.name;
 263                                 if (CharOperation.equals(name, selector)) {
 264                                         if (valueAttribute == null && CharOperation.equals(name, TypeConstants.VALUE)) {
 265                                                 valueAttribute = pair;
 266                                         }
 267                                         pair.binding = method;
 268                                         pair.resolveTypeExpecting(scope, method.returnType);
 269                                         pairs[j] = null; // consumed
 270                                         foundValue = true;
 271
 272                                         // check duplicates
 273                                         boolean foundDuplicate = false;
 274                                         for (int k = j+1; k < pairsLength; k++) {
 275                                                 MemberValuePair otherPair = pairs[k];
 276                                                 if (otherPair == null) continue;
 277                                                 if (CharOperation.equals(otherPair.name, selector)) {
 278                                                         foundDuplicate = true;
 279                                                         scope.problemReporter().duplicateAnnotationValue(annotationType, otherPair);
 280                                                         otherPair.binding = method;
 281                                                         otherPair.resolveTypeExpecting(scope, method.returnType);
 282                                                         pairs[k] = null;
 283                                                 }
 284                                         }
 285                                         if (foundDuplicate) {
 286                                                 scope.problemReporter().duplicateAnnotationValue(annotationType, pair);
 287                                                 continue nextMember;
 288                                         }
 289                                 }
 290                         }
 291                         if (!foundValue &&
 292                                         (method.modifiers & ClassFileConstants.AccAnnotationDefault) == 0 &&
 293                                         (this.bits & IsRecovered) == 0) {
 294                                 scope.problemReporter().missingValueForAnnotationMember(this, selector);
 295                         }
 296                 }
 297                 // check unused pairs
 298                 for (int i = 0; i < pairsLength; i++) {
 299                         if (pairs[i] != null) {
 300                                 scope.problemReporter().undefinedAnnotationValue(annotationType, pairs[i]);
 301                                 pairs[i].resolveTypeExpecting(scope, null); // resilient
 302                         }
 303                 }
 304 //              if (scope.compilerOptions().storeAnnotations)
 305                 this.compilerAnnotation = scope.environment().createAnnotation((ReferenceBinding) this.resolvedType, this.computeElementValuePairs());
 306                 // recognize standard annotations ?
 307                 long tagBits = detectStandardAnnotation(scope, annotationType, valueAttribute);
 308
 309                 // record annotation positions in the compilation result
 310                 scope.referenceCompilationUnit().recordSuppressWarnings(CompilerOptions.NonExternalizedString, null, this.sourceStart, this.declarationSourceEnd);
 311                 if (this.recipient != null) {
 312                         if (tagBits != 0) {
 313                                 // tag bits onto recipient
 314                                 switch (this.recipient.kind()) {
 315                                         case Binding.PACKAGE :
 316                                                 ((PackageBinding)this.recipient).tagBits |= tagBits;
 317                                                 break;
 318                                         case Binding.TYPE :
 319                                         case Binding.GENERIC_TYPE :
 320                                                 SourceTypeBinding sourceType = (SourceTypeBinding) this.recipient;
 321                                                 sourceType.tagBits |= tagBits;
 322                                                 if ((tagBits & TagBits.AnnotationSuppressWarnings) != 0) {
 323                                                         TypeDeclaration typeDeclaration =  sourceType.scope.referenceContext;
 324                                                         int start;
 325                                                         if (scope.referenceCompilationUnit().types[0] == typeDeclaration) {
 326                                                                 start = 0;
 327                                                         } else {
 328                                                                 start = typeDeclaration.declarationSourceStart;
 329                                                         }
 330                                                         recordSuppressWarnings(scope, start, typeDeclaration.declarationSourceEnd, scope.compilerOptions().suppressWarnings);
 331                                                 }
 332                                                 break;
 333                                         case Binding.METHOD :
 334                                                 MethodBinding sourceMethod = (MethodBinding) this.recipient;
 335                                                 sourceMethod.tagBits |= tagBits;
 336                                                 if ((tagBits & TagBits.AnnotationSuppressWarnings) != 0) {
 337                                                         sourceType = (SourceTypeBinding) sourceMethod.declaringClass;
 338                                                         AbstractMethodDeclaration methodDeclaration = sourceType.scope.referenceContext.declarationOf(sourceMethod);
 339                                                         recordSuppressWarnings(scope, methodDeclaration.declarationSourceStart, methodDeclaration.declarationSourceEnd, scope.compilerOptions().suppressWarnings);
 340                                                 }
 341                                                 break;
 342                                         case Binding.FIELD :
 343                                                 FieldBinding sourceField = (FieldBinding) this.recipient;
 344                                                 sourceField.tagBits |= tagBits;
 345                                                 if ((tagBits & TagBits.AnnotationSuppressWarnings) != 0) {
 346                                                         sourceType = (SourceTypeBinding) sourceField.declaringClass;
 347                                                         FieldDeclaration fieldDeclaration = sourceType.scope.referenceContext.declarationOf(sourceField);
 348                                                         recordSuppressWarnings(scope, fieldDeclaration.declarationSourceStart, fieldDeclaration.declarationSourceEnd, scope.compilerOptions().suppressWarnings);
 349                                                 }
 350                                                 break;
 351                                         case Binding.LOCAL :
 352                                                 LocalVariableBinding variable = (LocalVariableBinding) this.recipient;
 353                                                 variable.tagBits |= tagBits;
 354                                                 if ((tagBits & TagBits.AnnotationSuppressWarnings) != 0) {
 355                                                          LocalDeclaration localDeclaration = variable.declaration;
 356                                                         recordSuppressWarnings(scope, localDeclaration.declarationSourceStart, localDeclaration.declarationSourceEnd, scope.compilerOptions().suppressWarnings);
 357                                                 }
 358                                                 break;
 359                                 }
 360                         }
 361                         // check (meta)target compatibility
 362                         checkTargetCompatibility: {
 363                                 long metaTagBits = annotationType.getAnnotationTagBits(); // could be forward reference
 364                                 if ((metaTagBits & TagBits.AnnotationTargetMASK) == 0) // does not specify any target restriction
 365                                         break checkTargetCompatibility;
 366
 367                                 switch (recipient.kind()) {
 368                                         case Binding.PACKAGE :
 369                                                 if ((metaTagBits & TagBits.AnnotationForPackage) != 0)
 370                                                         break checkTargetCompatibility;
 371                                                 break;
 372                                         case Binding.TYPE :
 373                                         case Binding.GENERIC_TYPE :
 374                                                 if (((ReferenceBinding)this.recipient).isAnnotationType()) {
 375                                                         if ((metaTagBits & (TagBits.AnnotationForAnnotationType|TagBits.AnnotationForType)) != 0)
 376                                                         break checkTargetCompatibility;
 377                                                 } else if ((metaTagBits & TagBits.AnnotationForType) != 0)
 378                                                         break checkTargetCompatibility;
 379                                                 break;
 380                                         case Binding.METHOD :
 381                                                 if (((MethodBinding)this.recipient).isConstructor()) {
 382                                                         if ((metaTagBits & TagBits.AnnotationForConstructor) != 0)
 383                                                                 break checkTargetCompatibility;
 384                                                 } else  if ((metaTagBits & TagBits.AnnotationForMethod) != 0)
 385                                                         break checkTargetCompatibility;
 386                                                 break;
 387                                         case Binding.FIELD :
 388                                                 if ((metaTagBits & TagBits.AnnotationForField) != 0)
 389                                                         break checkTargetCompatibility;
 390                                                 break;
 391                                         case Binding.LOCAL :
 392                                                 if ((((LocalVariableBinding)this.recipient).tagBits & TagBits.IsArgument) != 0) {
 393                                                         if ((metaTagBits & TagBits.AnnotationForParameter) != 0)
 394                                                                 break checkTargetCompatibility;
 395                                                 } else  if ((annotationType.tagBits & TagBits.AnnotationForLocalVariable) != 0)
 396                                                         break checkTargetCompatibility;
 397                                                 break;
 398                                 }
 399                                 scope.problemReporter().disallowedTargetForAnnotation(this);
 400                         }
 401                 }
 402                 return this.resolvedType;
 403         }
 404
 405         public abstract void traverse(ASTVisitor visitor, BlockScope scope);
 406
 407 }