Handle deferred access as pre-step in SemanticSendVisitor.

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 309 matching lines @@
           element = reportAndCreateErroneousElement(
               node, name, MessageKind.GENERIC,
               // TODO(ahe): Improve error message. Need UX input.
               {'text': "is not an expression $element"});
         }
       }
       if (!Elements.isUnresolved(element) && element.isClass) {
         ClassElement classElement = element;
         classElement.ensureResolved(compiler);
       }
-      return new ElementResult(registry.useElement(node, element));
+      if (element != null) {
+        registry.useElement(node, element);
+        if (element.isPrefix) {
+          return new PrefixResult(element, null);
+        } else if (element.isClass && sendIsMemberAccess) {
+          return new PrefixResult(null, element);
+        }
+        return new ElementResult(element);
+      }
+      return const NoneResult();
     }
   }
 
   TypeResult visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
     if (inCheckContext) {
       registry.registerIsCheck(type);
     }
     return new TypeResult(type);
   }
@@ skipping 1290 matching lines @@
       } else {
         switch (operator.kind) {
           case UnaryOperatorKind.NOT:
             return handleNot(node, operator);
           case UnaryOperatorKind.COMPLEMENT:
           case UnaryOperatorKind.NEGATE:
             assert(invariant(node, operator.isUserDefinable,
                 message: "Unexpected unary operator '${operator}'."));
             return handleUserDefinableUnary(node, operator);
         }
-        return handleUserDefinableUnary(node, operator);
       }
     } else {
       BinaryOperator operator = BinaryOperator.parse(operatorText);
       if (operator == null) {
         return handleUnresolvedBinary(node, operatorText);
       } else {
         switch (operator.kind) {
           case BinaryOperatorKind.LOGICAL_AND:
             return handleLogicalAnd(node);
           case BinaryOperatorKind.LOGICAL_OR:
@@ skipping 248 matching lines @@
   /// 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 handleClassSend(
       Send node,
       Name name,
       ClassElement cls) {
     cls.ensureResolved(compiler);
     if (sendIsMemberAccess) {
       registry.useElement(node, cls);
-      return new ElementResult(cls);
+      return new PrefixResult(null, cls);
     } else {
       // `C` or `C()` where 'C' is a class.
       return handleClassTypeLiteralAccess(node, name, cls);
     }
   }
 
+  /// Compute a [DeferredPrefixStructure] for [node].
+  ResolutionResult handleDeferredAccess(
+      Send node,
+      PrefixElement prefix,
+      ResolutionResult result) {
+    assert(invariant(node, prefix.isDeferred,
+        message: "Prefix $prefix is not deferred."));
+    SendStructure sendStructure = registry.getSendStructure(node);
+    assert(invariant(node, sendStructure !=  null,
+        message: "No SendStructure for $node."));
+    registry.registerSendStructure(node,
+        new DeferredPrefixStructure(prefix, sendStructure));
+    if (result.isConstant) {
+      ConstantExpression constant =
+          new DeferredConstantExpression(result.constant, prefix);
+      registry.setConstant(node, constant);
+      result = new ConstantResult(node, constant);
+    }
+    return result;
+  }
+
   /// Handle qualified [Send] where the receiver resolves to a [prefix],
   /// like `prefix.toplevelFunction()` or `prefix.Class.staticField` where
   /// `prefix` is a library prefix.
   ResolutionResult handleLibraryPrefixSend(
       Send node, PrefixElement prefix, Name name) {
+    ResolutionResult result;
     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);
+      result = handleUnresolvedAccess(node, name, error);
     } else {
-      return handleResolvedSend(node, name, member);
+      result = handleResolvedSend(node, name, member);
     }
+    if (result.kind == ResultKind.PREFIX) {
+      // [member] is a class prefix of a static access like `prefix.Class` of
+      // `prefix.Class.foo`. No need to call [handleDeferredAccess]; it will
+      // called on the parent `prefix.Class.foo` node.
+      result = new PrefixResult(prefix, result.element);
+    } else if (prefix.isDeferred &&
+               (member == null || !member.isDeferredLoaderGetter)) {
+      result = handleDeferredAccess(node, prefix, result);
+    }
+    return result;
   }
 
   /// 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);
+    return new PrefixResult(prefix, null);
   }
 
   /// 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) {
+  /// `a.b` where `a` is a prefix or a class.
+  ResolutionResult handlePrefixSend(
+      Send node, Name name, PrefixResult prefixResult) {
+    Element element = prefixResult.element;
     if (element.isPrefix) {
       return handleLibraryPrefixSend(node, element, name);
-    } else if (element.isClass) {
-      return handleStaticMemberAccess(node, name, element);
+    } else {
+      assert(element.isClass);
+      ResolutionResult result = handleStaticMemberAccess(node, name, element);
+      if (prefixResult.isDeferred) {
+        result = handleDeferredAccess(node, prefixResult.prefix, result);
+      }
+      return result;
     }
-    // TODO(johnniwinther): Use the [element].
-    return handleDynamicPropertyAccess(node, name);
   }
 
   /// Handle dynamic access of [semantics].
   ResolutionResult handleDynamicAccessSemantics(
       Send node, Name name, AccessSemantics semantics) {
     SendStructure sendStructure;
     Selector selector;
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
@@ skipping 59 matching lines @@
       if (checkThisAccess(node)) {
         return handleThisPropertyAccess(node, name);
       }
       // TODO(johnniwinther): Handle invalid this access as an
       // [AccessSemantics].
       return const NoneResult();
     } else if (node.isConditional) {
       return handleConditionalAccess(node, name);
     }
     ResolutionResult result = visitExpressionPrefix(node.receiver);
-    if (result.element != null) {
-      return handleResolvedQualifiedSend(node, name, result.element);
+    if (result.kind == ResultKind.PREFIX) {
+      return handlePrefixSend(node, name, result);
     } else {
+      // TODO(johnniwinther): Use the `element` of [result].
       return handleDynamicPropertyAccess(node, name);
     }
   }
 
   /// Handle access unresolved access to [name] in a non-instance context.
   ResolutionResult handleUnresolvedAccess(
         Send node, Name name, Element element) {
     // TODO(johnniwinther): Support unresolved top level access as an
     // [AccessSemantics].
     AccessSemantics accessSemantics = new StaticAccess.unresolved(element);
@@ skipping 380 matching lines @@
       return handleOperatorSend(node);
     } else if (node.receiver != null) {
       // `a.b`.
       return handleQualifiedSend(node);
     } else {
       // `a`.
       return handleUnqualifiedSend(node);
     }
   }
 
-  /// Regigster read access of [target] inside a closure.
+  /// Register read access of [target] inside a closure.
   void registerPotentialAccessInClosure(Send node, Element target) {
     if (isPotentiallyMutableTarget(target)) {
       if (enclosingElement != target.enclosingElement) {
         for (Node scope in promotionScope) {
           registry.setAccessedByClosureIn(scope, target, node);
         }
       }
     }
   }
 
@@ skipping 1313 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);
 }