Version 0.8.10.4

dart/editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/resolver/ElementResolver.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 219 matching lines @@
     public Element getStaticElement() {
       return null;
     }
 
     @Override
     public void visitChildren(ASTVisitor<?> visitor) {
     }
   }
 
   /**
+   * Checks if the given expression is the reference to the type, if it is then the
+   * {@link ClassElement} is returned, otherwise {@code null} is returned.
+   * 
+   * @param expr the expression to evaluate
+   * @return the {@link ClassElement} if the given expression is the reference to the type, and
+   *         {@code null} otherwise
+   */
+  public static ClassElementImpl getTypeReference(Expression expr) {
+    if (expr instanceof Identifier) {
+      Identifier identifier = (Identifier) expr;
+      if (identifier.getStaticElement() instanceof ClassElementImpl) {
+        return (ClassElementImpl) identifier.getStaticElement();
+      }
+    }
+    return null;
+  }
+
+  /**
    * @return {@code true} if the given identifier is the return type of a constructor declaration.
    */
   private static boolean isConstructorReturnType(SimpleIdentifier node) {
     ASTNode parent = node.getParent();
     if (parent instanceof ConstructorDeclaration) {
       ConstructorDeclaration constructor = (ConstructorDeclaration) parent;
       return constructor.getReturnType() == node;
     }
     return false;
   }
@@ skipping 680 matching lines @@
     if (target instanceof SuperExpression && !isSuperInValidContext((SuperExpression) target)) {
       return null;
     }
     Element staticElement;
     Element propagatedElement;
     if (target == null) {
       staticElement = resolveInvokedElement(methodName);
       propagatedElement = null;
     } else {
       Type staticType = getStaticType(target);
-      staticElement = resolveInvokedElement(target, staticType, methodName);
-      propagatedElement = resolveInvokedElement(target, getPropagatedType(target), methodName);
+      //
+      // If this method invocation is of the form 'C.m' where 'C' is a class, then we don't call
+      // resolveInvokedElement(..) which walks up the class hierarchy, instead we just look for the
+      // member in the type only.
+      //
+      ClassElementImpl typeReference = getTypeReference(target);
+      if (typeReference != null) {
+        staticElement = propagatedElement = resolveElement(typeReference, methodName.getName());
+      } else {
+        staticElement = resolveInvokedElement(target, staticType, methodName);
+        propagatedElement = resolveInvokedElement(target, getPropagatedType(target), methodName);
+      }
     }
     staticElement = convertSetterToGetter(staticElement);
     propagatedElement = convertSetterToGetter(propagatedElement);
     //
     // Record the results.
     //
     methodName.setStaticElement(staticElement);
     methodName.setPropagatedElement(propagatedElement);
     ArgumentList argumentList = node.getArgumentList();
     if (staticElement != null) {
@@ skipping 210 matching lines @@
             element = setter;
           }
         }
       }
       // TODO(brianwilkerson) The prefix needs to be resolved to the element for the import that
       // defines the prefix, not the prefix's element.
       identifier.setStaticElement(element);
       // Validate annotation element.
       if (node.getParent() instanceof Annotation) {
         Annotation annotation = (Annotation) node.getParent();
-        resolveAnnotationElement(annotation, element, null);
+        resolveAnnotationElement(annotation);
         return null;
       }
       return null;
     }
 
     // May be annotation, resolve invocation of "const" constructor.
     if (node.getParent() instanceof Annotation) {
       Annotation annotation = (Annotation) node.getParent();
-      resolveAnnotationElement(annotation, prefixElement, identifier);
+      resolveAnnotationElement(annotation);
     }
 
     //
     // Otherwise, the prefix is really an expression that happens to be a simple identifier and this
     // is really equivalent to a property access node.
     //
     resolvePropertyAccess(prefix, identifier);
     return null;
   }
 
@@ skipping 139 matching lines @@
           enclosingType,
           node.getName()), null);
       node.setAuxiliaryElements(auxiliaryElements);
     }
 
     //
     // Validate annotation element.
     //
     if (node.getParent() instanceof Annotation) {
       Annotation annotation = (Annotation) node.getParent();
-      resolveAnnotationElement(annotation, element, null);
+      resolveAnnotationElement(annotation);
     }
     return null;
   }
 
   @Override
   public Void visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     ClassElement enclosingClass = resolver.getEnclosingClass();
     if (enclosingClass == null) {
       // TODO(brianwilkerson) Report this error.
       return null;
@@ skipping 936 matching lines @@
       return;
     }
     // resolve arguments to parameters
     ParameterElement[] parameters = resolveArgumentsToParameters(true, argumentList, constructor);
     if (parameters != null) {
       argumentList.setCorrespondingStaticParameters(parameters);
     }
   }
 
   /**
-   * Validates that the given {@link Element} is the constant variable; or resolves it as a
-   * constructor invocation.
+   * Continues resolution of the given {@link Annotation}.
    * 
    * @param annotation the {@link Annotation} to resolve
-   * @param element the current known {@link Element} of the annotation, or {@link ClassElement}
-   * @param nameNode the name of the invoked constructor, may be {@code null} if unnamed constructor
-   *          or not a constructor invocation
    */
-  private void resolveAnnotationElement(Annotation annotation, Element element,
-      SimpleIdentifier nameNode) {
-    // constant variable
-    if (element instanceof PropertyAccessorElement) {
-      PropertyAccessorElement accessorElement = (PropertyAccessorElement) element;
-      // accessor should be synthetic
-      if (!accessorElement.isSynthetic()) {
-        resolver.reportError(CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
+  private void resolveAnnotationElement(Annotation annotation) {
+    SimpleIdentifier nameNode1;
+    SimpleIdentifier nameNode2;
+    {
+      Identifier annName = annotation.getName();
+      if (annName instanceof PrefixedIdentifier) {
+        PrefixedIdentifier prefixed = (PrefixedIdentifier) annName;
+        nameNode1 = prefixed.getPrefix();
+        nameNode2 = prefixed.getIdentifier();
+      } else {
+        nameNode1 = (SimpleIdentifier) annName;
+        nameNode2 = null;
+      }
+    }
+    SimpleIdentifier nameNode3 = annotation.getConstructorName();
+    ConstructorElement constructor = null;
+    //
+    // CONST or Class(args)
+    //
+    if (nameNode1 != null && nameNode2 == null && nameNode3 == null) {
+      Element element1 = nameNode1.getStaticElement();
+      // CONST
+      if (element1 instanceof PropertyAccessorElement) {
+        resolveAnnotationElementGetter(annotation, (PropertyAccessorElement) element1);
         return;
       }
-      // variable should be constant
-      VariableElement variableElement = accessorElement.getVariable();
-      if (!variableElement.isConst()) {
-        resolver.reportError(CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
+      // Class(args)
+      if (element1 instanceof ClassElement) {
+        ClassElement classElement = (ClassElement) element1;
+        constructor = new InterfaceTypeImpl(classElement).lookUpConstructor(null, definingLibrary);
       }
-      // OK
+    }
+    //
+    // prefix.CONST or prefix.Class() or Class.CONST or Class.constructor(args)
+    //
+    if (nameNode1 != null && nameNode2 != null && nameNode3 == null) {
+      Element element1 = nameNode1.getStaticElement();
+      Element element2 = nameNode2.getStaticElement();
+      // Class.CONST - not resolved yet
+      if (element1 instanceof ClassElement) {
+        ClassElement classElement = (ClassElement) element1;
+        element2 = classElement.lookUpGetter(nameNode2.getName(), definingLibrary);
+      }
+      // prefix.CONST or Class.CONST
+      if (element2 instanceof PropertyAccessorElement) {
+        nameNode2.setStaticElement(element2);
+        annotation.setElement(element2);
+        resolveAnnotationElementGetter(annotation, (PropertyAccessorElement) element2);
+        return;
+      }
+      // prefix.Class()
+      if (element2 instanceof ClassElement) {
+        ClassElement classElement = (ClassElement) element2;
+        constructor = classElement.getUnnamedConstructor();
+      }
+      // Class.constructor(args)
+      if (element1 instanceof ClassElement) {
+        ClassElement classElement = (ClassElement) element1;
+        constructor = new InterfaceTypeImpl(classElement).lookUpConstructor(
+            nameNode2.getName(),
+            definingLibrary);
+        nameNode2.setStaticElement(constructor);
+      }
+    }
+    //
+    // prefix.Class.CONST or prefix.Class.constructor(args)
+    //
+    if (nameNode1 != null && nameNode2 != null && nameNode3 != null) {
+      Element element2 = nameNode2.getStaticElement();
+      // element2 should be ClassElement
+      if (element2 instanceof ClassElement) {
+        ClassElement classElement = (ClassElement) element2;
+        String name3 = nameNode3.getName();
+        // prefix.Class.CONST
+        PropertyAccessorElement getter = classElement.lookUpGetter(name3, definingLibrary);
+        if (getter != null) {
+          nameNode3.setStaticElement(getter);
+          annotation.setElement(element2);
+          resolveAnnotationElementGetter(annotation, getter);
+          return;
+        }
+        // prefix.Class.constructor(args)
+        constructor = new InterfaceTypeImpl(classElement).lookUpConstructor(name3, definingLibrary);
+        nameNode3.setStaticElement(constructor);
+      }
+    }
+    // we need constructor
+    if (constructor == null) {
+      resolver.reportError(CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
       return;
     }
-    // const constructor invocation
-    if (element instanceof ClassElement) {
-      // prepare constructor name
-      if (nameNode == null) {
-        nameNode = annotation.getConstructorName();
-      }
-      String name = nameNode != null ? nameNode.getName() : null;
-      // look up ConstructorElement
-      ConstructorElement constructor;
-      {
-        InterfaceType interfaceType = new InterfaceTypeImpl((ClassElement) element);
-        constructor = interfaceType.lookUpConstructor(name, definingLibrary);
-      }
-      // not a constructor
-      if (constructor == null) {
-        resolver.reportError(CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
-        return;
-      }
-      // record element
-      annotation.setElement(constructor);
-      if (nameNode != null) {
-        nameNode.setStaticElement(constructor);
-      }
-      // resolve arguments
-      resolveAnnotationConstructorInvocationArguments(annotation, constructor);
-      // OK
+    // record element
+    annotation.setElement(constructor);
+    // resolve arguments
+    resolveAnnotationConstructorInvocationArguments(annotation, constructor);
+  }
+
+  private void resolveAnnotationElementGetter(Annotation annotation,
+      PropertyAccessorElement accessorElement) {
+    // accessor should be synthetic
+    if (!accessorElement.isSynthetic()) {
+      resolver.reportError(CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
       return;
     }
-    // something unknown
-    if (element != null) {
+    // variable should be constant
+    VariableElement variableElement = accessorElement.getVariable();
+    if (!variableElement.isConst()) {
       resolver.reportError(CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
     }
+    // OK
+    return;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or {@code null} if no correspondence could be computed.
    * 
    * @param reportError if {@code true} then compile-time error should be reported; if {@code false}
    *          then compile-time warning
    * @param argumentList the list of arguments being passed to the element
@@ skipping 111 matching lines @@
       for (SimpleIdentifier name : names) {
         Element element = namespace.get(name.getName());
         if (element != null) {
           name.setStaticElement(element);
         }
       }
     }
   }
 
   /**
+   * Given an invocation of the form 'C.x()' where 'C' is a class, find and return the element 'x'
+   * in 'C'.
+   * 
+   * @param classElement the class element
+   * @param memberName the member name
+   */
+  private Element resolveElement(ClassElementImpl classElement, String memberName) {
+    Element element = null;
+    String methodNameStr = memberName;
+    element = classElement.getMethod(methodNameStr);
+    if (element == null) {
+      element = classElement.getSetter(memberName);
+      if (element == null) {
+        element = classElement.getGetter(memberName);
+      }
+    }
+    if (element != null && element.isAccessibleIn(definingLibrary)) {
+      return element;
+    }
+    return null;
+  }
+
+  /**
    * Given an invocation of the form 'e.m(a1, ..., an)', resolve 'e.m' to the element being invoked.
    * If the returned element is a method, then the method will be invoked. If the returned element
    * is a getter, the getter will be invoked without arguments and the result of that invocation
    * will then be invoked with the arguments.
    * 
    * @param target the target of the invocation ('e')
    * @param targetType the type of the target
    * @param methodName the name of the method being invoked ('m')
    * @return the element being invoked
    */
@@ skipping 84 matching lines @@
       memberElement = lookUpGetter(target, targetType, propertyName.getName());
     }
     if (memberElement == null) {
       memberElement = lookUpMethod(target, targetType, propertyName.getName());
     }
     return memberElement;
   }
 
   private void resolvePropertyAccess(Expression target, SimpleIdentifier propertyName) {
     Type staticType = getStaticType(target);
-    ExecutableElement staticElement = resolveProperty(target, staticType, propertyName);
+    Type propagatedType = getPropagatedType(target);
+
+    Element staticElement = null;
+    Element propagatedElement = null;
+
+    //
+    // If this property access is of the form 'C.m' where 'C' is a class, then we don't call
+    // resolveProperty(..) which walks up the class hierarchy, instead we just look for the
+    // member in the type only.
+    //
+    ClassElementImpl typeReference = getTypeReference(target);
+    if (typeReference != null) {
+      staticElement = propagatedElement = resolveElement(typeReference, propertyName.getName());
+    } else {
+      staticElement = resolveProperty(target, staticType, propertyName);
+      propagatedElement = resolveProperty(target, propagatedType, propertyName);
+    }
 
     // May be part of annotation, record property element only if exists.
     // Error was already reported in validateAnnotationElement().
     if (target.getParent().getParent() instanceof Annotation) {
       if (staticElement != null) {
         propertyName.setStaticElement(staticElement);
       }
       return;
     }
+
     propertyName.setStaticElement(staticElement);
-
-    Type propagatedType = getPropagatedType(target);
-    ExecutableElement propagatedElement = resolveProperty(target, propagatedType, propertyName);
     propertyName.setPropagatedElement(propagatedElement);
 
     boolean shouldReportMissingMember_static = shouldReportMissingMember(staticType, staticElement)
         && (strictMode || shouldReportMissingMember(propagatedType, propagatedElement));
     boolean shouldReportMissingMember_propagated = !shouldReportMissingMember_static && enableHints
         ? shouldReportMissingMember(propagatedType, propagatedElement) : false;
 
     // If we are about to generate the hint (propagated version of this warning), then check
     // that the member is not in a subtype of the propagated type.
     if (shouldReportMissingMember_propagated) {
@@ skipping 170 matching lines @@
   }
 
   /**
    * Return {@code true} if we should report an error as a result of looking up a member in the
    * given type and not finding any member.
    * 
    * @param type the type in which we attempted to perform the look-up
    * @param member the result of the look-up
    * @return {@code true} if we should report an error
    */
-  private boolean shouldReportMissingMember(Type type, ExecutableElement member) {
+  private boolean shouldReportMissingMember(Type type, Element member) {
     if (member != null || type == null || type.isDynamic() || type.isBottom()) {
       return false;
     }
     return true;
   }
 }