Refactor handling of library prefixes.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of resolution;
 
 /// The state of constants in resolutions.
 enum ConstantState {
   /// Expressions are not required to be constants.
   NON_CONSTANT,
@@ skipping 28 matching lines @@
   /// Whether we are in a context where `this` is accessible (this will be false
   /// in static contexts, factory methods, and field initializers).
   bool inInstanceContext;
   bool inCheckContext;
   bool inCatchBlock;
   ConstantState constantState;
 
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
+
+  /// `true` if a [Send] or [SendSet] is visited as the prefix of member access.
+  /// For instance `Class` in `Class.staticField` or `prefix.Class` in
+  /// `prefix.Class.staticMethod()`.
   bool sendIsMemberAccess = false;
+
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
       | ElementCategory.IMPLIES_TYPE;
 
   /**
    * Record of argument nodes to JS_INTERCEPTOR_CONSTANT for deferred
    * processing.
    */
   Set<Node> argumentsToJsInterceptorConstant = null;
 
@@ skipping 1265 matching lines @@
       visitExpression(right);
     } else {
       ResolutionResult leftResult = visitExpression(left);
       ResolutionResult rightResult = visitExpression(right);
       registry.registerDynamicInvocation(new UniverseSelector(selector, null));
       semantics = new DynamicAccess.dynamicProperty(left);
 
       if (leftResult.isConstant && rightResult.isConstant) {
         bool isValidConstant;
         ConstantExpression leftConstant = leftResult.constant;
-        ConstantExpression rightConstant = leftResult.constant;
+        ConstantExpression rightConstant = rightResult.constant;
         DartType knownLeftType = leftConstant.getKnownType(coreTypes);
         DartType knownRightType = rightConstant.getKnownType(coreTypes);
         switch (operator.kind) {
           case BinaryOperatorKind.EQ:
           case BinaryOperatorKind.NOT_EQ:
             isValidConstant =
                 (knownLeftType == coreTypes.intType ||
                  knownLeftType == coreTypes.doubleType ||
                  knownLeftType == coreTypes.stringType ||
                  knownLeftType == coreTypes.boolType ||
@@ skipping 417 matching lines @@
       return handleStaticInstanceMemberAccess(
           node, memberName, receiverClass, member);
     } else if (memberName.isPrivate && memberName.library != member.library) {
       return handlePrivateStaticMemberAccess(
           node, memberName, receiverClass, member);
     } else {
       return handleStaticOrTopLevelAccess(node, memberName, member);
     }
   }
 
+  /// Handle qualified [Send] where the reciever resolves to a [prefix],

[karlklose, 2015/07/09 13:42:49]

'reciever' -> 'receiver'.

[Johnni Winther, 2015/07/09 13:52:04]

Done.

+  /// like `prefix.toplevelFunction()` or `prefix.Class.staticField` where
+  /// `prefix` is a library prefix.
+  ResolutionResult handleLibraryPrefixSend(
+      Send node, PrefixElement prefix, Name name) {
+    Element member = prefix.lookupLocalMember(name.text);
+    if (member == null) {
+      registry.registerThrowNoSuchMethod();
+      Element error = reportAndCreateErroneousElement(
+          node, name.text, MessageKind.NO_SUCH_LIBRARY_MEMBER,
+          {'libraryName': prefix.name, 'memberName': name});
+      registry.useElement(node, error);
+      return new ElementResult(error);
+    } else {
+      return handleResolvedSend(node, name, member);
+    }
+  }
+
+  /// Handle a [Send] that resolves to a [prefix]. Like `prefix` in
+  /// `prefix.Class` or `prefix` in `prefix()`, the latter being a compile time
+  /// error.
+  ResolutionResult handleLibraryPrefix(
+      Send node,
+      Name name,
+      PrefixElement prefix) {
+    if ((ElementCategory.PREFIX & allowedCategory) == 0) {
+      compiler.reportError(
+          node,
+          MessageKind.PREFIX_AS_EXPRESSION,
+          {'prefix': name});
+      return const NoneResult();
+    }
+    if (prefix.isDeferred) {
+      // TODO(johnniwinther): Remove this when deferred access is detected
+      // through a [SendStructure].
+      registry.useElement(node.selector, prefix);
+    }
+    registry.useElement(node, prefix);
+    return new ElementResult(prefix);
+  }
+
+
   /// Handle qualified [Send] where the receiver resolves to an [Element], like
   /// `a.b` where `a` is a local, field, class, or prefix, etc.
   ResolutionResult handleResolvedQualifiedSend(
       Send node, Name name, Element element) {
     if (element.isPrefix) {
-      return oldVisitSend(node);
+      return handleLibraryPrefixSend(node, element, name);
     } else if (element.isClass) {
       return handleStaticMemberAccess(node, name, element);
     }
     return oldVisitSend(node);
   }
 
   /// Handle dynamic access of [semantics].
   ResolutionResult handleDynamicAccessSemantics(
       Send node, Name name, AccessSemantics semantics) {
     SendStructure sendStructure;
@@ skipping 113 matching lines @@
     registry.registerSendStructure(node, sendStructure);
     return const NoneResult();
   }
 
   /// Handle access to an ambiguous element, that is, a name imported twice.
   ResolutionResult handleAmbiguousSend(
       Send node,
       Name name,
       AmbiguousElement element) {
 
-    compiler.reportError(
-        node, element.messageKind, element.messageArguments);
+    ErroneousElement error = reportAndCreateErroneousElement(
+        node,
+        name.text,
+        element.messageKind,
+        element.messageArguments);
     element.diagnose(enclosingElement, compiler);
-
-    ErroneousElement error = new ErroneousElementX(
-        element.messageKind,
-        element.messageArguments,
-        name.text,
-        enclosingElement);
+    registry.registerThrowNoSuchMethod();
 
     // TODO(johnniwinther): Support ambiguous access as an [AccessSemantics].
     AccessSemantics accessSemantics = new StaticAccess.unresolved(error);
     return handleErroneousAccess(node, name, error, accessSemantics);
   }
 
   /// Handle access of an instance [member] from a non-instance context.
   ResolutionResult handleStaticInstanceSend(
       Send node, Name name, MemberElement member) {
     compiler.reportError(
@@ skipping 254 matching lines @@
         return handleThisPropertyAccess(node, name);
       } else {
         return handleStaticInstanceSend(node, name, element);
       }
     }
     if (element.isClass || element.isTypedef) {
       return oldVisitSend(node);
     } else if (element.isTypeVariable) {
       return oldVisitSend(node);
     } else if (element.isPrefix) {
-      return oldVisitSend(node);
+      return handleLibraryPrefix(node, name, element);
     } else if (element.isLocal) {
       return handleLocalAccess(node, name, element);
     } else if (element.isStatic || element.isTopLevel) {
       return handleStaticOrTopLevelAccess(node, name, element);
     }
     return internalError(node, "Unexpected resolved send: $element");
   }
 
   /// Handle an unqualified [Send], that is where the `node.receiver` is null,
   /// like `a`, `a()`, `this()`, `assert()`, and `(){}()`.
@@ skipping 1467 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }