Version 0.8.10.4

dart/editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/verifier/ErrorVerifier.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 155 matching lines @@
    * formal, and finally, initialized in the initializers list.
    */
   private enum INIT_STATE {
     NOT_INIT,
     INIT_IN_DECLARATION,
     INIT_IN_FIELD_FORMAL,
     INIT_IN_INITIALIZERS
   }
 
   /**
-   * Checks if the given expression is the reference to the type.
-   * 
-   * @param expr the expression to evaluate
-   * @return {@code true} if the given expression is the reference to the type
-   */
-  private static boolean isTypeReference(Expression expr) {
-    if (expr instanceof Identifier) {
-      Identifier identifier = (Identifier) expr;
-      return identifier.getStaticElement() instanceof ClassElement;
-    }
-    return false;
-  }
-
-  /**
    * The error reporter by which errors will be reported.
    */
   private ErrorReporter errorReporter;
 
   /**
    * The current library that is being analyzed.
    */
   private LibraryElement currentLibrary;
 
   /**
@@ skipping 621 matching lines @@
     } finally {
       enclosingFunction = previousFunction;
       isInStaticMethod = false;
     }
   }
 
   @Override
   public Void visitMethodInvocation(MethodInvocation node) {
     Expression target = node.getRealTarget();
     SimpleIdentifier methodName = node.getMethodName();
-    checkForStaticAccessToInstanceMember(target, methodName);
-    checkForInstanceAccessToStaticMember(target, methodName);
-    if (target == null) {
+    if (target != null) {
+      ClassElement typeReference = ElementResolver.getTypeReference(target);
+      checkForStaticAccessToInstanceMember(typeReference, methodName);
+      checkForInstanceAccessToStaticMember(typeReference, methodName);
+    } else {
       checkForUnqualifiedReferenceToNonLocalStaticMember(methodName);
     }
     return super.visitMethodInvocation(node);
   }
 
   @Override
   public Void visitNativeClause(NativeClause node) {
     // TODO(brianwilkerson) Figure out the right rule for when 'native' is allowed.
     if (!isInSystemLibrary) {
       errorReporter.reportError(ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE, node);
@@ skipping 10 matching lines @@
   @Override
   public Void visitPostfixExpression(PostfixExpression node) {
     checkForAssignmentToFinal(node.getOperand());
     checkForIntNotAssignable(node.getOperand());
     return super.visitPostfixExpression(node);
   }
 
   @Override
   public Void visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (!(node.getParent() instanceof Annotation)) {
-      checkForStaticAccessToInstanceMember(node.getPrefix(), node.getIdentifier());
-      checkForInstanceAccessToStaticMember(node.getPrefix(), node.getIdentifier());
+      ClassElement typeReference = ElementResolver.getTypeReference(node.getPrefix());
+      SimpleIdentifier name = node.getIdentifier();
+      checkForStaticAccessToInstanceMember(typeReference, name);
+      checkForInstanceAccessToStaticMember(typeReference, name);
     }
     return super.visitPrefixedIdentifier(node);
   }
 
   @Override
   public Void visitPrefixExpression(PrefixExpression node) {
     TokenType operatorType = node.getOperator().getType();
     Expression operand = node.getOperand();
     if (operatorType == TokenType.BANG) {
       checkForNonBoolNegationExpression(operand);
     } else if (operatorType.isIncrementOperator()) {
       checkForAssignmentToFinal(operand);
     }
     checkForIntNotAssignable(operand);
     return super.visitPrefixExpression(node);
   }
 
   @Override
   public Void visitPropertyAccess(PropertyAccess node) {
-    Expression target = node.getRealTarget();
+    ClassElement typeReference = ElementResolver.getTypeReference(node.getRealTarget());
     SimpleIdentifier propertyName = node.getPropertyName();
-    checkForStaticAccessToInstanceMember(target, propertyName);
-    checkForInstanceAccessToStaticMember(target, propertyName);
+    checkForStaticAccessToInstanceMember(typeReference, propertyName);
+    checkForInstanceAccessToStaticMember(typeReference, propertyName);
     return super.visitPropertyAccess(node);
   }
 
   @Override
   public Void visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     isInConstructorInitializer = true;
     try {
       return super.visitRedirectingConstructorInvocation(node);
     } finally {
       isInConstructorInitializer = false;
@@ skipping 2418 matching lines @@
     if (errors == null || errors.isEmpty()) {
       return false;
     }
     for (AnalysisError error : errors) {
       errorReporter.reportError(error);
     }
     return true;
   }
 
   /**
-   * This checks that if the given "target" is not a type reference then the "name" is reference to
-   * an instance member.
+   * This checks the given "typeReference" is not a type reference and that then the "name" is
+   * reference to an instance member.
    * 
-   * @param target the target of the name access to evaluate
+   * @param typeReference the resolved {@link ClassElement} of the left hand side of the expression,
+   *          or {@code null}, aka, the class element of 'C' in 'C.x', see
+   *          {@link #getTypeReference(Expression)}
    * @param name the accessed name to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INSTANCE_ACCESS_TO_STATIC_MEMBER
    */
-  private boolean checkForInstanceAccessToStaticMember(Expression target, SimpleIdentifier name) {
-    // OK, no target
-    if (target == null) {
+  private boolean checkForInstanceAccessToStaticMember(ClassElement typeReference,
+      SimpleIdentifier name) {
+    // OK, in comment
+    if (isInComment) {
       return false;
     }
-    // OK, in comment
-    if (isInComment) {
+    // OK, target is a type
+    if (typeReference != null) {
       return false;
     }
     // prepare member Element
     Element element = name.getStaticElement();
     if (!(element instanceof ExecutableElement)) {
       return false;
     }
     ExecutableElement executableElement = (ExecutableElement) element;
     // OK, top-level element
     if (!(executableElement.getEnclosingElement() instanceof ClassElement)) {
       return false;
     }
     // OK, instance member
     if (!executableElement.isStatic()) {
       return false;
     }
-    // OK, target is a type
-    if (isTypeReference(target)) {
-      return false;
-    }
     // report problem
     errorReporter.reportError(
         StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER,
         name,
         name.getName());
     return true;
   }
 
   /**
    * This verifies that an 'int' can be assigned to the parameter corresponding to the given
@@ skipping 1199 matching lines @@
           StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
           returnExpression,
           staticReturnType.getDisplayName(),
           expectedReturnType.getDisplayName(),
           enclosingFunction.getDisplayName());
       return true;
     }
   }
 
   /**
-   * This checks that if the given "target" is the type reference then the "name" is not the
-   * reference to a instance member.
+   * This checks the given "typeReference" and that the "name" is not the reference to an instance
+   * member.
    * 
-   * @param target the target of the name access to evaluate
+   * @param typeReference the resolved {@link ClassElement} of the left hand side of the expression,
+   *          or {@code null}, aka, the class element of 'C' in 'C.x', see
+   *          {@link #getTypeReference(Expression)}
    * @param name the accessed name to evaluate
    * @return {@code true} if and only if an error code is generated on the passed node
    * @see StaticWarningCode#STATIC_ACCESS_TO_INSTANCE_MEMBER
    */
-  private boolean checkForStaticAccessToInstanceMember(Expression target, SimpleIdentifier name) {
+  private boolean checkForStaticAccessToInstanceMember(ClassElement typeReference,
+      SimpleIdentifier name) {
+    // OK, target is not a type
+    if (typeReference == null) {
+      return false;
+    }
     // prepare member Element
     Element element = name.getStaticElement();
     if (!(element instanceof ExecutableElement)) {
       return false;
     }
     ExecutableElement memberElement = (ExecutableElement) element;
     // OK, static
     if (memberElement.isStatic()) {
       return false;
     }
-    // OK, target is not a type
-    if (!isTypeReference(target)) {
-      return false;
-    }
     // report problem
     errorReporter.reportError(
         StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER,
         name,
         name.getName());
     return true;
   }
 
   /**
    * This checks that the type of the passed 'switch' expression is assignable to the type of the
@@ skipping 793 matching lines @@
       if (superClassElt != null) {
         return memberHasConcreteMethodImplementationInSuperclassChain(
             superClassElt,
             methodName,
             superclassChain);
       }
     }
     return false;
   }
 }