Don't wrap type literals that are referenced by prefixes.

lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 2019 matching lines @@
     if (accessor is PropertyAccessorElement) element = accessor.variable;
 
     _loader.declareBeforeUse(element);
 
     // type literal
     if (element is TypeDefiningElement) {
       var typeName = _emitTypeName(fillDynamicTypeArgs(element.type));
 
       // If the type is a type literal expression in Dart code, wrap the raw
       // runtime type in a "Type" instance.
-      if (!_isInForeignJS &&
-          node.parent is! MethodInvocation &&
-          node.parent is! PrefixedIdentifier &&
-          node.parent is! PropertyAccess) {
+      if (!_isInForeignJS && _isTypeLiteral(node)) {
         typeName = js.call('dart.wrapType(#)', typeName);
       }
 
       return typeName;
     }
 
     // library member
     if (element.enclosingElement is CompilationUnitElement) {
       return _emitTopLevelName(element);
     }
@@ skipping 27 matching lines @@
     }
 
     // If this is one of our compiler's temporary variables, return its JS form.
     if (element is TemporaryVariableElement) {
       return element.jsVariable;
     }
 
     return new JS.Identifier(name);
   }
 
+  /// Returns `true` if the type name referred to by [node] is used in a
+  /// position where it should evaluate as a type literal -- an object of type
+  /// Type.
+  bool _isTypeLiteral(SimpleIdentifier node) {
+    var parent = node.parent;
+
+    // Static member call.
+    if (parent is MethodInvocation || parent is PropertyAccess) return false;
+
+    // An expression like "a.b".
+    if (parent is PrefixedIdentifier) {
+      // In "a.b", "b" may be a type literal, but "a", is not.
+      if (node != parent.identifier) return false;
+
+      // If the prefix expression is itself used as an invocation, like
+      // "a.b.c", then "b" is not a type literal.
+      var grand = parent.parent;
+      if (grand is MethodInvocation || grand is PropertyAccess) return false;
+
+      return true;
+    }
+
+    // In any other context, it's a type literal.
+    return true;
+  }
+
   JS.Identifier _emitParameter(ParameterElement element,
       {bool declaration: false}) {
     // initializing formal parameter, e.g. `Point(this._x)`
     // TODO(jmesserly): type ref is not attached in this case.
     if (element.isInitializingFormal && element.isPrivate) {
       /// Rename private names so they don't shadow the private field symbol.
       /// The renamer would handle this, but it would prefer to rename the
       /// temporary used for the private symbol. Instead rename the parameter.
       return _initializingFormalTemps.putIfAbsent(
           element, () => new JS.TemporaryId(element.name.substring(1)));
@@ skipping 2175 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';