Redo how Type objects are exposed from DDC.

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 98 matching lines @@
   FunctionBody _currentFunction;
 
   /// Helper class for emitting elements in the proper order to allow
   /// JS to load the module.
   ElementLoader _loader;
 
   BuildUnit _buildUnit;
 
   String _buildRoot;
 
+  /// Whether we are currently generating code for the body of a `JS()` call.
+  bool _isInForeignJS = false;
+
   CodeGenerator(AnalysisContext c, this.options, this._extensionTypes)
       : context = c,
         types = c.typeProvider,
         _asyncStreamIterator =
             _getLibrary(c, 'dart:async').getType('StreamIterator').type,
         _jsArray = _getLibrary(c, 'dart:_interceptors').getType('JSArray'),
         dartCoreLibrary = _getLibrary(c, 'dart:core'),
         dartJSLibrary = _getLibrary(c, 'dart:js');
 
   LibraryElement get currentLibrary => _loader.currentElement.library;
@@ skipping 83 matching lines @@
 
     // Collect all Element -> Node mappings, in case we need to forward declare
     // any nodes.
     var nodes = new HashMap<Element, AstNode>.identity();
     compilationUnits.map(_collectElements).forEach(nodes.addAll);
     _loader = new ElementLoader(_emitModuleItem, nodes);
 
     // Add implicit dart:core dependency so it is first.
     emitLibraryName(dartCoreLibrary);
 
-    //
     // Visit each compilation unit and emit its code.
     //
     // NOTE: declarations are not necessarily emitted in this order.
     // Order will be changed as needed so the resulting code can execute.
     // This is done by forward declaring items.
     compilationUnits.forEach(visitCompilationUnit);
 
     // Declare imports
     _finishImports(items);
 
@@ skipping 1769 matching lines @@
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
 
     _loader.declareBeforeUse(element);
 
     // type literal
     if (element is TypeDefiningElement) {
-      return _emitTypeName(fillDynamicTypeArgs(element.type));
+      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) {
+        // A type literal expression in use. Wrap the runtime type in a "Type" object.

[Jennifer Messerly, 2016/05/03 20:59:54]

long line.

[Bob Nystrom, 2016/05/03 21:24:32]

Oops. Meant to delete that comment (I moved it outside of the if()). Fixed.

+        typeName = js.call('dart.wrapType(#)', typeName);
+      }
+
+      return typeName;
     }
 
     // library member
     if (element.enclosingElement is CompilationUnitElement) {
       return _emitTopLevelName(element);
     }
 
     var name = element.name;
 
     // Unqualified class member. This could mean implicit-this, or implicit
@@ skipping 447 matching lines @@
             return '#';
           } else {
             return (element as InterpolationString).value;
           }
         }).join();
       } else {
         templateArgs = args.skip(2);
         source = (code as StringLiteral).stringValue;
       }
 
-      var template = js.parseForeignJS(source);
-      var result = template.instantiate(_visitList(templateArgs));
-      // `throw` is emitted as a statement by `parseForeignJS`.
-      assert(result is JS.Expression || node.parent is ExpressionStatement);
-      return result;
+      // TODO(rnystrom): The JS() calls are almost never nested, and probably
+      // really shouldn't be, but there are at least a couple of calls in the
+      // HTML library where an argument to JS() is itself a JS() call. If those

[Jennifer Messerly, 2016/05/03 20:59:54]

haha, wow. The crazy stuff you find sometimes :)

[Bob Nystrom, 2016/05/03 21:24:32]

Acknowledged.

+      // go away, this can just assert(!_isInForeignJS).
+      var wasInForeignJS = _isInForeignJS;
+      try {

[Jennifer Messerly, 2016/05/03 20:59:54]

nit: try/finally is not needed. We will never try and reuse this visitor
instance if something goes wrong and throws (that means an internal compiler
error). So handling an exception is not required.

[Bob Nystrom, 2016/05/03 21:24:32]

Done.

+        _isInForeignJS = true;
+
+        var template = js.parseForeignJS(source);
+        var result = template.instantiate(_visitList(templateArgs));
+        // `throw` is emitted as a statement by `parseForeignJS`.
+        assert(result is JS.Expression || node.parent is ExpressionStatement);
+        return result;
+      } finally {
+        _isInForeignJS = wasInForeignJS;
+      }
     }
     return null;
   }
 
   @override
   JS.Expression visitFunctionExpressionInvocation(
           FunctionExpressionInvocation node) =>
       _emitFunctionCall(node);
 
   @override
@@ skipping 1730 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';