Angular template workarounds

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 108 matching lines @@
   /// Helper class for emitting elements in the proper order to allow
   /// JS to load the module.
   ElementLoader _loader;
 
   BuildUnit _buildUnit;
 
   String _buildRoot;
 
   bool _superAllowed = true;
 
+  bool _inAngularTemplate = false;
+
   List<JS.TemporaryId> _superHelperSymbols = <JS.TemporaryId>[];
   List<JS.Method> _superHelpers = <JS.Method>[];
 
   List<TypeParameterType> _typeParamInConst = null;
 
   /// 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,
@@ skipping 278 matching lines @@
 
     if (item != null) _moduleItems.add(item);
   }
 
   void _declareBeforeUse(Element e) {
     _loader.declareBeforeUse(e, _emitDeclaration);
   }
 
   @override
   void visitCompilationUnit(CompilationUnit unit) {
+    _inAngularTemplate =

[Jennifer Messerly, 2016/05/26 18:19:02]

can we have this guarded by a compile flag please?

+        unit.element.source.fullName.endsWith(".template.dart");

[Jennifer Messerly, 2016/05/26 18:19:02]

So, this doesn't work... I should put a comment on visitCompilationUnit saying
"don't put stuff here!"

We don't visit things in order. So you'll end up affecting arbitrary other
libraries that aren't in .template.dart files.

The right way to check for this at the place of use. See how currentLibrary
works.

You can also do per-compilation-unit caching in _emitModuleItem.

+
     _constField = new ConstFieldVisitor(types, unit.element.source);
 
     for (var declaration in unit.declarations) {
       var element = declaration.element;
       if (element != null) {
         _emitDeclaration(element);
       } else {
         declaration.accept(this);
       }
     }
     for (var directive in unit.directives) {
       directive.accept(this);
     }
+    _inAngularTemplate = false;
   }
 
   @override
   void visitLibraryDirective(LibraryDirective node) {}
 
   @override
   void visitImportDirective(ImportDirective node) {
     // We don't handle imports here.
     //
     // Instead, we collect imports whenever we need to generate a reference
@@ skipping 85 matching lines @@
         return js.call('dart.asInt(#)', jsFrom);
       }
 
       // A no-op in JavaScript.
       return jsFrom;
     }
 
     var type = _emitType(to,
         nameType: options.nameTypeTests || options.hoistTypeTests,
         hoistType: options.hoistTypeTests);
+    if (_inAngularTemplate) return jsFrom;
     return js.call('dart.as(#, #)', [jsFrom, type]);
   }
 
   @override
   visitIsExpression(IsExpression node) {
     // Generate `is` as `dart.is` or `typeof` depending on the RHS type.
     JS.Expression result;
     var type = node.type.type;
     var lhs = _visit(node.expression);
     var typeofName = _jsTypeofName(type);
@@ skipping 1158 matching lines @@
         }
       }
 
       // TODO(jmesserly): various problems here, see:
       // https://github.com/dart-lang/dev_compiler/issues/116
       var paramType = param.element.type;
       if (node is MethodDeclaration && _unsoundCovariant(paramType, true)) {
         var castType = _emitType(paramType,
             nameType: options.nameTypeTests || options.hoistTypeTests,
             hoistType: options.hoistTypeTests);
-        body.add(js.statement('dart.as(#, #);', [jsParam, castType]));
+        if (!_inAngularTemplate) {
+          body.add(js.statement('dart.as(#, #);', [jsParam, castType]));
+        }
       }
     }
     return body.isEmpty ? null : _statement(body);
   }
 
   /// Given a type [t], return whether or not t is unsoundly covariant.
   /// If [contravariant] is true, then t appears in a contravariant
   /// position.
   bool _unsoundCovariant(DartType t, bool contravariant) {
     if (t is TypeParameterType) {
@@ skipping 776 matching lines @@
       }
 
       target = _getTarget(lhs);
       id = lhs.propertyName;
     } else if (lhs is PrefixedIdentifier) {
       target = lhs.prefix;
       id = lhs.identifier;
     }
 
     if (target != null && DynamicInvoke.get(target)) {
+      if (_inAngularTemplate) {
+        return _visit(rhs).toAssignExpression(_visit(lhs));
+      }
       return js.call('dart.dput(#, #, #)',
           [_visit(target), _emitMemberName(id.name), _visit(rhs)]);
     }
 
     return _visit(rhs).toAssignExpression(_visit(lhs));
   }
 
   JS.Expression _emitNullSafeSet(PropertyAccess node, Expression right) {
     // Emit `obj?.prop = expr` as:
     //
@@ skipping 110 matching lines @@
       List<JS.Expression> args,
       List<JS.Expression> typeArgs) {
     var type = getStaticType(target);
     var name = node.methodName.name;
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
     JS.Expression jsTarget = _visit(target);
     if (DynamicInvoke.get(target) || DynamicInvoke.get(node.methodName)) {
+      if (_inAngularTemplate) {
+        jsTarget = new JS.PropertyAccess(jsTarget, memberName);
+        if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
+        return new JS.Call(jsTarget, args);
+      }
       if (typeArgs != null) {
         return js.call('dart.dgsend(#, #, #, #)',
             [jsTarget, new JS.ArrayInitializer(typeArgs), memberName, args]);
       } else {
         return js.call('dart.dsend(#, #, #)', [jsTarget, memberName, args]);
       }
     }
     if (_isObjectMemberCall(target, name)) {
       assert(typeArgs == null); // Object methods don't take type args.
       return js.call('dart.#(#, #)', [name, jsTarget, args]);
     }
 
     jsTarget = new JS.PropertyAccess(jsTarget, memberName);
     if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
 
     return new JS.Call(jsTarget, args);
   }
 
   /// Emits a function call, to a top-level function, local function, or
   /// an expression.
   JS.Expression _emitFunctionCall(InvocationExpression node) {
     var fn = _visit(node.function);
     var args = _visit(node.argumentList);
     if (DynamicInvoke.get(node.function)) {
       var typeArgs = _emitInvokeTypeArguments(node);
       if (typeArgs != null) {
         return js.call('dart.dgcall(#, #, #)',
             [fn, new JS.ArrayInitializer(typeArgs), args]);
       } else {
+        if (_inAngularTemplate) {
+          return new JS.Call(fn, args);
+        }
         return js.call('dart.dcall(#, #)', [fn, args]);
       }
     } else {
       return new JS.Call(_applyInvokeTypeArguments(fn, node), args);
     }
   }
 
   JS.Expression _applyInvokeTypeArguments(
       JS.Expression target, InvocationExpression node) {
     var typeArgs = _emitInvokeTypeArguments(node);
@@ skipping 1158 matching lines @@
     if (type == null) return null;
     return _emitFunctionTypeArguments(type, instantiated);
   }
 
   JS.Expression _emitAccessInternal(Expression target, Element member,
       String memberName, List<JS.Expression> typeArgs) {
     bool isStatic = member is ClassMemberElement && member.isStatic;
     var name = _emitMemberName(memberName,
         type: getStaticType(target), isStatic: isStatic);
     if (DynamicInvoke.get(target)) {
+      if (_inAngularTemplate) {
+        return js.call('#.#', [_visit(target), name]);
+      }
       return js.call('dart.dload(#, #)', [_visit(target), name]);
     }
 
     var jsTarget = _visit(target);
     bool isSuper = jsTarget is JS.Super;
 
     if (isSuper && member is FieldElement && !member.isSynthetic) {
       // If super.x is actually a field, then x is an instance property since
       // subclasses cannot override x.
       jsTarget = new JS.This();
@@ skipping 30 matching lines @@
       Expression target, String name, List<Expression> args) {
     var type = getStaticType(target);
     var memberName = _emitMemberName(name, unary: args.isEmpty, type: type);
     if (DynamicInvoke.get(target)) {
       // dynamic dispatch
       var dynamicHelper = const {'[]': 'dindex', '[]=': 'dsetindex'}[name];
       if (dynamicHelper != null) {
         return js.call(
             'dart.$dynamicHelper(#, #)', [_visit(target), _visitList(args)]);
       }
-      return js.call('dart.dsend(#, #, #)',
-          [_visit(target), memberName, _visitList(args)]);
+      if (_inAngularTemplate) {
+        return js
+            .call('#.#(#)', [_visit(target), memberName, _visitList(args)]);
+      } else {
+        return js.call('dart.dsend(#, #, #)',
+            [_visit(target), memberName, _visitList(args)]);
+      }
     }
 
     // Generic dispatch to a statically known method.
     return js.call('#.#(#)', [_visit(target), memberName, _visitList(args)]);
   }
 
   @override
   visitIndexExpression(IndexExpression node) {
     var target = _getTarget(node);
     if (_useNativeJsIndexer(target.staticType)) {
@@ skipping 713 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';