dart2dart: Support for all constants in new backend.

sdk/lib/_internal/compiler/implementation/ir/ir_builder.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder;
 
 import 'ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../source_file.dart';
 import '../tree/tree.dart' as ast;
 import '../scanner/scannerlib.dart' show Token, isUserDefinableOperator;
 import '../dart_backend/dart_backend.dart' show DartBackend;
 import '../universe/universe.dart' show SelectorKind;
 import '../util/util.dart' show Link;
+import '../helpers/helpers.dart';
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
  *
  * The functionality of the IrNodes is added gradually, therefore elements might
  * have an IR or not, depending on the language features that are used. For
  * elements that do have an IR, the tree [ast.Node]s and the [Token]s are not
  * used in the rest of the compilation. This is ensured by setting the element's
@@ skipping 76 matching lines @@
     if (signature.optionalParameterCount > 0) return false;
 
     // TODO(kmillikin): support getters and setters and static class members.
     // With the current Dart Tree emitter they just require recognizing them
     // and generating the correct syntax.
     if (element.isGetter || element.isSetter) return false;
 
     // TODO(lry): support native functions (also in [visitReturn]).
     if (function.isNative) return false;
 
+    // TODO(asgerf): support syntax for redirecting factory constructors
+    if (function is ConstructorElement && function.isRedirectingFactory) {
+      return false;
+    }
+
     return true;
   }
 
   bool get inCheckedMode {
     bool result = false;
     assert((result = true));
     return result;
   }
 
   SourceFile elementSourceFile(Element element) {
@@ skipping 486 matching lines @@
               entryArguments)));
       current = resultContext;
     } else {
       add(resultContext);
     }
     return null;
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isOpen);
+    if (node.modifiers.isConst) return giveup(node); // TODO(asgerf): const vars
     for (ast.Node definition in node.definitions.nodes) {
       Element element = elements[definition];
       // Definitions are either SendSets if there is an initializer, or
       // Identifiers if there is no initializer.
       if (definition is ast.SendSet) {
         assert(!definition.arguments.isEmpty);
         assert(definition.arguments.tail.isEmpty);
         ir.Primitive initialValue = visit(definition.arguments.head);
         // In case a primitive was introduced for the initializer expression,
         // use this variable element to help derive a good name for it.
@@ skipping 16 matching lines @@
     return null;
   }
 
   // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
   //   where (C', x) = Build(e, C)
   //
   // Return without a subexpression is translated as if it were return null.
   ir.Primitive visitReturn(ast.Return node) {
     assert(isOpen);
     // TODO(lry): support native returns.
-    if (node.beginToken.value == 'native') return giveup();
+    if (node.beginToken.value == 'native') return giveup(node);
     ir.Primitive value;
     if (node.expression == null) {
       value = new ir.Constant(constantSystem.createNull());
       add(new ir.LetPrim(value));
     } else {
       value = visit(node.expression);
     }
     add(new ir.InvokeContinuation(returnContinuation, [value]));
     current = null;
     return null;
@@ skipping 96 matching lines @@
   }
 
   Constant getConstantForNode(ast.Node node) {
     Constant constant =
         compiler.backend.constants.getConstantForNode(node, elements);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
     return constant;
   }
 
-  bool isSupportedConst(Constant constant) {
-    return const SupportedConstantVisitor().visit(constant);
-  }
-
   ir.Primitive visitLiteralList(ast.LiteralList node) {
     assert(isOpen);
-    ir.Primitive result;
-    if (node.isConst) {
-      // TODO(sigurdm): Remove when all constants are supported.
-      Constant constant = getConstantForNode(node);
-      if (!isSupportedConst(constant)) return giveup();
-      result = new ir.Constant(constant);
-    } else {
-      List<ir.Primitive> values = new List<ir.Primitive>();
-      node.elements.nodes.forEach((ast.Node node) {
-        values.add(visit(node));
-      });
-      result = new ir.LiteralList(values);
-    }
+    List<ir.Primitive> values = node.elements.nodes.mapToList(visit);
+    Constant constant = node.isConst ? getConstantForNode(node) : null;
+    GenericType type = elements.getType(node);
+    ir.Primitive result = new ir.LiteralList(type, values, constant);
     add(new ir.LetPrim(result));
     return result;
   }
 
   ir.Primitive visitLiteralMap(ast.LiteralMap node) {
     assert(isOpen);
-    ir.Primitive result;
-    if (node.isConst) {
-      // TODO(sigurdm): Remove when all constants are supported.
-      Constant constant = getConstantForNode(node);
-      if (!isSupportedConst(constant)) return giveup();
-      result = new ir.Constant(constant);
-    } else {
-      List<ir.Primitive> keys = new List<ir.Primitive>();
-      List<ir.Primitive> values = new List<ir.Primitive>();
-      node.entries.nodes.forEach((ast.LiteralMapEntry node) {
-        keys.add(visit(node.key));
-        values.add(visit(node.value));
-      });
-      result = new ir.LiteralMap(keys, values);
-    }
+    List<ir.Primitive> keys = new List<ir.Primitive>();
+    List<ir.Primitive> values = new List<ir.Primitive>();
+    node.entries.nodes.forEach((ast.LiteralMapEntry node) {
+      keys.add(visit(node.key));
+      values.add(visit(node.value));
+    });
+    GenericType type = elements.getType(node);
+    Constant constant = node.isConst ? getConstantForNode(node) : null;
+    ir.Primitive result = new ir.LiteralMap(type, keys, values, constant);
     add(new ir.LetPrim(result));
     return result;
   }
 
   ir.Primitive visitLiteralSymbol(ast.LiteralSymbol node) {
     assert(isOpen);
     ir.Constant constant = new ir.Constant(getConstantForNode(node));
     add(new ir.LetPrim(constant));
     return constant;
   }
@@ skipping 26 matching lines @@
 
   ir.Primitive lookupLocal(Element element) {
     int index = variableIndex[element];
     ir.Primitive value = assignedVars[index];
     return value == null ? freeVars[index] : value;
   }
 
   // ==== Sends ====
   ir.Primitive visitAssert(ast.Send node) {
     assert(isOpen);
-    return giveup();
+    return giveup(node);
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
     assert(isOpen);
     return visit(node.expression);
   }
 
   ir.Primitive visitClosureSend(ast.Send node) {
     assert(isOpen);
     Selector closureSelector = elements.getSelector(node);
@@ skipping 19 matching lines @@
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression invoke =
         new ir.InvokeMethod(closureTarget, namedCallSelector, k, arguments);
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
   ir.Primitive visitDynamicSend(ast.Send node) {
     assert(isOpen);
     if (node.receiver == null || node.receiver.isSuper()) {
-      return giveup();
+      return giveup(node);
     }
     Selector selector = elements.getSelector(node);
     ir.Primitive receiver = visit(node.receiver);
     List<ir.Primitive> arguments = new List<ir.Primitive>();
     for (ast.Node n in node.arguments) {
       arguments.add(visit(n));
     }
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression invoke =
         new ir.InvokeMethod(receiver, selector, k, arguments);
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
   ir.Primitive visitGetterSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       return lookupLocal(element);
     } else if (element == null || Elements.isInstanceField(element)) {
       // TODO: Support implicit this.
-      if (node.receiver == null) return giveup();
+      if (node.receiver == null) return giveup(node);
 
       ir.Primitive receiver = visit(node.receiver);
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.GETTER);
       ir.InvokeMethod invoke = new ir.InvokeMethod(receiver, selector, k, []);
       add(new ir.LetCont(k, invoke));
       return v;
     } else if (element.isField) {
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.GETTER);
       ir.InvokeStatic invoke = new ir.InvokeStatic(element, selector, k, []);
       add(new ir.LetCont(k, invoke));
       return v;
+    } else if (Elements.isStaticOrTopLevelFunction(element)) {
+      ir.Primitive prim = new ir.Constant(new FunctionConstant(element));
+      add(new ir.LetPrim(prim));
+      return prim;
     } else {
-      return giveup(); // TODO: figure out what's missing here
+      return giveup(node); // TODO(asgerf): figure out what's missing here
     }
   }
 
   ir.Primitive translateLogicalOperator(ast.Operator op,
                                         ast.Expression left,
                                         ast.Expression right) {
     // e0 && e1 is translated as if e0 ? (e1 == true) : false.
     // e0 || e1 is translated as if e0 ? true : (e1 == true).
     // The translation must convert both e0 and e1 to booleans and handle
     // local variable assignments in e1.
@@ skipping 84 matching lines @@
     ast.Operator op = node.selector;
     if (isUserDefinableOperator(op.source)) {
       return visitDynamicSend(node);
     }
     if (op.source == '&&' || op.source == '||') {
       assert(node.receiver != null);
       assert(!node.arguments.isEmpty);
       assert(node.arguments.tail.isEmpty);
       return translateLogicalOperator(op, node.receiver, node.arguments.head);
     }
-    return giveup();
+    return giveup(node);
   }
 
   // Build(StaticSend(f, arguments), C) = C[C'[InvokeStatic(f, xs)]]
   //   where (C', xs) = arguments.fold(Build, C)
   ir.Primitive visitStaticSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     // TODO(lry): support constructors / factory calls.
-    if (element.isConstructor) return giveup();
+    if (element.isConstructor) return giveup(node);
     // TODO(lry): support foreign functions.
-    if (element.isForeign(compiler)) return giveup();
+    if (element.isForeign(compiler)) return giveup(node);
     // TODO(lry): for elements that could not be resolved emit code to throw a
     // [NoSuchMethodError].
-    if (element.isErroneous) return giveup();
+    if (element.isErroneous) return giveup(node);
     // TODO(lry): generate IR for object identicality.
-    if (element == compiler.identicalFunction) giveup();
+    if (element == compiler.identicalFunction) giveup(node);
 
     Selector selector = elements.getSelector(node);
 
     // TODO(lry): support default arguments, need support for locals.
     List<ir.Definition> arguments = node.arguments.mapToList(visit,
                                                              growable:false);
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression invoke =
         new ir.InvokeStatic(element, selector, k, arguments);
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
   ir.Primitive visitSuperSend(ast.Send node) {
     assert(isOpen);
-    return giveup();
+    return giveup(node);
   }
 
   ir.Primitive visitTypeReferenceSend(ast.Send node) {
     assert(isOpen);
-    return giveup();
+    if (node.argumentsNode != null) {
+      // May happen in strange, invalid code.
+      // TODO(asgerf): Generate code that throws a runtime error.
+      return giveup(node);
+    }
+    Element element = elements[node];
+    if (element is TypeDeclarationElement) {
+      DartType typeType = compiler.backend.typeImplementation.rawType;
+      ir.Primitive prim =
+          new ir.Constant(new TypeConstant(element.rawType, typeType));
+      add(new ir.LetPrim(prim));
+      return prim;
+    } else if (element.isTypeVariable) {
+      // TODO(asgerf): Introduce IR to reify type variables
+      return giveup(node);
+    } else {
+      // TODO(asgerf): Any other cases?
+      return giveup(node);
+    }
   }
 
   ir.Primitive visitSendSet(ast.SendSet node) {
     assert(isOpen);
     Element element = elements[node];
     ast.Operator op = node.assignmentOperator;
     ir.Primitive result;
     ir.Primitive getter;
     if (op.source == '=') {
       if (Elements.isLocal(element)) {
@@ skipping 12 matching lines @@
         Selector selector = elements.getSelector(node);
         ir.Definition arg = visit(node.arguments.head);
         ir.InvokeStatic invoke =
             new ir.InvokeStatic(element, selector, k, [arg]);
         add(new ir.LetCont(k, invoke));
         return arg;
       } else if (node.receiver == null) {
         // Nodes that fall in this case:
         // - Unresolved top-level
         // - Assignment to final variable (will not be resolved)
-        return giveup();
+        return giveup(node);
       } else {
         // Setter or index-setter invocation
         assert(node.receiver != null);
-        if (node.receiver.isSuper()) return giveup();
+        if (node.receiver.isSuper()) return giveup(node);
 
         ir.Primitive receiver = visit(node.receiver);
         ir.Parameter v = new ir.Parameter(null);
         ir.Continuation k = new ir.Continuation([v]);
         Selector selector = elements.getSelector(node);
         assert(selector.kind == SelectorKind.SETTER ||
             selector.kind == SelectorKind.INDEX);
         List<ir.Definition> args = node.arguments.mapToList(visit,
                                                             growable:false);
         ir.InvokeMethod invoke =
             new ir.InvokeMethod(receiver, selector, k, args);
         add(new ir.LetCont(k, invoke));
         return args.last;
       }
     } else if (ast.Operator.COMPLEX_OPERATORS.contains(op.source)) {
       Element selectorElement = elements[node.selector];
       if (selectorElement != null && !selectorElement.isAssignable) {
-        return giveup();
+        return giveup(node);
       }
-      if (!Elements.isLocal(selectorElement)) return giveup();
+      if (!Elements.isLocal(selectorElement)) return giveup(node);
 
       Selector selector = elements.getOperatorSelectorInComplexSendSet(node);
       getter = lookupLocal(selectorElement);
 
       ir.Primitive arg;
       if (ast.Operator.INCREMENT_OPERATORS.contains(op.source)) {
         assert(node.arguments.isEmpty);
         arg = new ir.Constant(constantSystem.createInt(1));
         add(new ir.LetPrim(arg));
       } else {
@@ skipping 19 matching lines @@
     } else {
       compiler.internalError(node, "Unknown assignment operator ${op.source}");
       return null;
     }
   }
 
   ir.Primitive visitNewExpression(ast.NewExpression node) {
     assert(isOpen);
     FunctionElement element = elements[node.send];
     if (Elements.isUnresolved(element)) {
-      return giveup();
+      return giveup(node);
     }
     Selector selector = elements.getSelector(node.send);
     ast.Node selectorNode = node.send.selector;
     GenericType type = elements.getType(node);
-    List<ir.Definition> args = node.send.arguments.mapToList(visit,
-                                                             growable:false);
+    List<ir.Primitive> args =
+        node.send.arguments.mapToList(visit, growable:false);
     if (node.isConst) {
-      List<ir.Primitive> arguments = new List<ir.Primitive>();
-      node.send.arguments.forEach((ast.Node node) {
-        arguments.add(visit(node));
-      });
-      ir.Primitive result = new ir.InvokeConstConstructor(type, element, selector,
-                                                     arguments);
+      ir.Primitive result = new ir.InvokeConstConstructor(type, element,
+          selector, args, getConstantForNode(node));
       add(new ir.LetPrim(result));
       return result;
     }
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
-    ir.InvokeConstructor invoke = new ir.InvokeConstructor(
-        type,
-        element,
-        selector,
-        k,
-        args);
+    ir.InvokeConstructor invoke =
+        new ir.InvokeConstructor(type, element,selector, k, args);
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     ir.Primitive first = visit(node.first);
     ir.Primitive second = visit(node.second);
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.ConcatenateStrings concat =
@@ skipping 13 matching lines @@
     }
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.ConcatenateStrings concat = new ir.ConcatenateStrings(k, arguments);
     add(new ir.LetCont(k, concat));
     return v;
   }
 
   static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
-  ir.Primitive giveup() => throw ABORT_IRNODE_BUILDER;
+  ir.Primitive giveup(ast.Node node) {
+    throw ABORT_IRNODE_BUILDER;
+  }

[asgerf, 2014/06/20 15:02:10]

I find myself adding and removing the node parameter a lot. It makes debugging
giveup() calls much easier. Can we please keep it?

[sigurdm, 2014/06/23 07:22:20]

Yes! And maybe we can even add an optional "reason" string.

[Kevin Millikin (Google), 2014/06/23 08:03:06]

Yes, please.

 
   ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
       return action();
     } catch(e) {
       if (e == ABORT_IRNODE_BUILDER) return null;
       rethrow;
     }
   }
 
   void internalError(String reason, {ast.Node node}) {
-    giveup();
+    giveup(node);
   }
 }
 
-// While we don't support all constants we need to filter out the unsupported
-// ones:
-class SupportedConstantVisitor extends ConstantVisitor<bool> {
-  const SupportedConstantVisitor();
-
-  bool visit(Constant constant) => constant.accept(this);
-  bool visitFunction(FunctionConstant constant) => false;
-  bool visitNull(NullConstant constant) => true;
-  bool visitInt(IntConstant constant) => true;
-  bool visitDouble(DoubleConstant constant) => true;
-  bool visitTrue(TrueConstant constant) => true;
-  bool visitFalse(FalseConstant constant) => true;
-  bool visitString(StringConstant constant) => true;
-  bool visitList(ListConstant constant) {
-    return constant.entries.every(visit);
-  }
-  bool visitMap(MapConstant constant) {
-    return visit(constant.keys) && constant.values.every(visit);
-  }
-  bool visitConstructed(ConstructedConstant constant) => false;
-  bool visitType(TypeConstant constant) => false;
-  bool visitInterceptor(InterceptorConstant constant) => false;
-  bool visitDummy(DummyConstant constant) => false;
-  bool visitDeferred(DeferredConstant constant) => false;
-}
-