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) {
+        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;
       }
 
+      // 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
+      // go away, this can just assert(!_isInForeignJS).
+      // Inside JS(), type names evaluate to the raw runtime type, not the
+      // wrapped Type object.
+      var wasInForeignJS = _isInForeignJS;
+      _isInForeignJS = true;
+
       var template = js.parseForeignJS(source);
       var result = template.instantiate(_visitList(templateArgs));
+
+      _isInForeignJS = wasInForeignJS;
+
       // `throw` is emitted as a statement by `parseForeignJS`.
       assert(result is JS.Expression || node.parent is ExpressionStatement);
       return result;
     }
     return null;
   }
 
   @override
   JS.Expression visitFunctionExpressionInvocation(
           FunctionExpressionInvocation node) =>
@@ skipping 1733 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';