Refactor handling of compounds.

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;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 2788 matching lines @@
         } else {
           seenNamedArguments[source] = namedArgument;
         }
       } else if (!seenNamedArguments.isEmpty) {
         error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
       }
     }
     sendIsMemberAccess = oldSendIsMemberAccess;
   }
 
+  void registerTypeLiteralAccess(Send node, Element target) {
+    // Set the type of the node to [Type] to mark this send as a
+    // type literal.
+    DartType type;
+
+    // TODO(johnniwinther): Remove this hack when we can pass more complex
+    // information between methods than resolved elements.
+    if (target == compiler.typeClass && node.receiver == null) {
+      // Potentially a 'dynamic' type literal.
+      type = registry.getType(node.selector);
+    }
+    if (type == null) {
+      type = target.computeType(compiler);
+    }
+    registry.registerTypeLiteral(node, type);
+
+    if (!target.isTypeVariable) {
+      // Don't try to make constants of calls and assignments to type literals.
+      if (!node.isCall && node.asSendSet() == null) {
+        analyzeConstantDeferred(node, enforceConst: false);
+      } else {
+        // The node itself is not a constant but we register the selector (the
+        // identifier that refers to the class/typedef) as a constant.
+        if (node.receiver != null) {
+          // This is a hack for the case of prefix.Type, we need to store
+          // the element on the selector, so [analyzeConstant] can build
+          // the type literal from the selector.
+          registry.useElement(node.selector, target);
+        }
+        analyzeConstantDeferred(node.selector, enforceConst: false);
+      }
+    }
+  }
+
   ResolutionResult visitSend(Send node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
     ResolutionResult result;
     if (node.isLogicalAnd) {
       result = doInPromotionScope(node.receiver, () => resolveSend(node));
     } else {
       result = resolveSend(node);
     }
     sendIsMemberAccess = oldSendIsMemberAccess;
@@ skipping 23 matching lines @@
       } else if (target.isTypeVariable) {
         ClassElement cls = target.enclosingClass;
         assert(enclosingElement.enclosingClass == cls);
         if (!Elements.hasAccessToTypeVariables(enclosingElement)) {
           compiler.reportError(node,
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
               {'typeVariableName': node.selector});
         }
         registry.registerClassUsingVariableExpression(cls);
         registry.registerTypeVariableExpression();
-        // Set the type of the node to [Type] to mark this send as a
-        // type variable expression.
-        registry.registerTypeLiteral(node, target.computeType(compiler));
+        registerTypeLiteralAccess(node, target);
       } else if (target.impliesType && (!sendIsMemberAccess || node.isCall)) {
-        // Set the type of the node to [Type] to mark this send as a
-        // type literal.
-        DartType type;
-
-        // TODO(johnniwinther): Remove this hack when we can pass more complex
-        // information between methods than resolved elements.
-        if (target == compiler.typeClass && node.receiver == null) {
-          // Potentially a 'dynamic' type literal.
-          type = registry.getType(node.selector);
-        }
-        if (type == null) {
-          type = target.computeType(compiler);
-        }
-        registry.registerTypeLiteral(node, type);
-
-        // Don't try to make constants of calls to type literals.
-        if (!node.isCall) {
-          analyzeConstantDeferred(node, enforceConst: false);
-        } else {
-          // The node itself is not a constant but we register the selector (the
-          // identifier that refers to the class/typedef) as a constant.
-          if (node.receiver != null) {
-            // This is a hack for the case of prefix.Type, we need to store
-            // the element on the selector, so [analyzeConstant] can build
-            // the type literal from the selector.
-            registry.useElement(node.selector, target);
-          }
-          analyzeConstantDeferred(node.selector, enforceConst: false);
-        }
+        registerTypeLiteralAccess(node, target);
       }
       if (isPotentiallyMutableTarget(target)) {
         if (enclosingElement != target.enclosingElement) {
           for (Node scope in promotionScope) {
             registry.setAccessedByClosureIn(scope, target, node);
           }
         }
       }
     }
 
@@ skipping 126 matching lines @@
         }
         if (isComplex && getter == null && !inInstanceContext) {
           getter = reportAndCreateErroneousElement(node.selector, field.name,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
           registry.registerThrowNoSuchMethod();
         }
       } else if (target.impliesType) {
         setter = reportAndCreateErroneousElement(node.selector, target.name,
             MessageKind.ASSIGNING_TYPE, const {});
         registry.registerThrowNoSuchMethod();
+        registerTypeLiteralAccess(node, target);
       } else if (target.isFinal || target.isConst) {
         if (Elements.isStaticOrTopLevelField(target) || target.isLocal) {
           setter = reportAndCreateErroneousElement(
               node.selector, target.name, MessageKind.CANNOT_RESOLVE_SETTER,
               const {});
         } else if (node.isSuperCall) {
           setter = reportAndCreateErroneousElement(
               node.selector, target.name, MessageKind.SETTER_NOT_FOUND_IN_SUPER,
               {'name': target.name, 'className': currentClass.name});
           registry.registerSuperNoSuchMethod();
@@ skipping 2120 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }