Build new IR for functions returning a constant

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 ir_builder;
+
+import 'ir_nodes.dart';
+import '../elements/elements.dart';
+import '../dart2jslib.dart';
+import '../source_file.dart';
+import '../tree/tree.dart';
+import '../scanner/scannerlib.dart' show Token;
+import '../js_backend/js_backend.dart' show JavaScriptBackend;
+
+class IrBuilderTask extends CompilerTask {
+  final Map<Element, IrNode> nodes = new Map<Element, IrNode>();
+
+  IrBuilderTask(Compiler compiler) : super(compiler);
+
+  String get name => 'IR builder';
+
+  void buildNodes() {
+    Map<Element, TreeElements> resolved =
+        compiler.enqueuer.resolution.resolvedElements;
+    resolved.forEach((Element element, TreeElements elementsMapping) {
+      element = element.implementation;
+
+      SourceFile sourceFile = elementSourceFile(element);
+      IrNodeBuilderVisitor visitor =
+          new IrNodeBuilderVisitor(elementsMapping, compiler, sourceFile);
+      IrNode irNode;
+      ElementKind kind = element.kind;
+      if (kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
+        // TODO(lry): build ir for constructors.
+      } else if (kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
+          kind == ElementKind.FUNCTION ||
+          kind == ElementKind.GETTER ||
+          kind == ElementKind.SETTER) {
+        irNode = visitor.buildMethod(element);
+      } else if (kind == ElementKind.FIELD) {
+        // TODO(lry): build ir for lazy initializers of static fields.
+      } else {
+        compiler.internalErrorOnElement(element,
+            'unexpected element kind $kind');
+      }
+
+      if (irNode != null) {
+        nodes[element] = irNode;
+        unlinkTreeAndToken(element);
+      }
+    });
+  }
+
+  void unlinkTreeAndToken(Element element) {

[ngeoffray, 2013/11/20 14:55:27]

I'd just untype element to avoid the 'as dynamic'.

[lukas, 2013/11/21 12:20:21]

Done.

+    if (compiler.backend is JavaScriptBackend) {
+      (element as dynamic).beginToken.next = null;
+      (element as dynamic).cachedNode = null;
+    }
+  }
+
+  SourceFile elementSourceFile(Element element) {
+    if (element is FunctionElement) {
+      FunctionElement functionElement = element;
+      if (functionElement.patch != null) element = functionElement.patch;
+    }
+    return element.getCompilationUnit().script.file;
+  }
+}
+
+
+class IrNodeBuilderVisitor extends ResolvedVisitor<IrNode> {
+  SourceFile sourceFile;
+
+  Context context;
+
+  IrNodeBuilderVisitor(TreeElements elements, Compiler compiler,
+      this.sourceFile) : super(elements, compiler) {

[ngeoffray, 2013/11/20 14:55:27]

Nit: One argument per line, and super on a new line.

[lukas, 2013/11/21 12:20:21]

Done.

+    context = new Context(this);
+  }
+
+  IrNode buildMethod(FunctionElement functionElement) {
+    assert(invariant(functionElement, functionElement.isImplementation));
+    FunctionExpression function = functionElement.parseNode(compiler);
+    assert(function != null);
+    assert(!function.modifiers.isExternal());
+    assert(elements[function] != null);
+    return buildNode(function);
+  }
+
+  IrNode buildNode(Node node) {
+    try {
+      return node.accept(this);
+    } catch(e) {
+      if (e == ABORT_IRNODE_BUILDER) return null;
+      rethrow;
+    }
+  }
+
+  ConstantSystem get constantSystem => compiler.backend.constantSystem;
+
+  /* int | PositionWithIdentifierName */ nodePosition(Node node) {
+    Token token = node.getBeginToken();
+    if (token.isIdentifier()) {
+      return new PositionWithIdentifierName(token.charOffset, token.value);
+    } else {
+      return token.charOffset;
+    }
+  }
+
+  IrNode visitFunctionExpression(FunctionExpression node) {
+    int endPosition = node.getEndToken().charOffset;
+    int namePosition = elements[node].position().charOffset;
+    IrFunction result = new IrFunction(
+        nodePosition(node), endPosition, namePosition, <IrNode>[]);
+    context.openFunction(result);
+    if (node.hasBody()) {
+      node.body.accept(this);
+      ensureReturn(node);
+      result.statements..addAll(context.constants)..addAll(context.statements);
+    }
+    context.closeFunction();
+    if (!context.isTopLevel()) {
+      context.enterStatement(result);
+    }
+    return result;
+  }
+
+  void ensureReturn(FunctionExpression node) {
+    if (!context.returnOnAllBranches) {
+      IrConstant nullValue =
+          context.enterConstant(constantSystem.createNull(), node);
+      context.enterStatement(new IrReturn(nodePosition(node), nullValue));
+    }
+  }
+
+  IrNode visitBlock(Block node) {
+    for (Node n in node.statements.nodes) {
+      n.accept(this);
+    }
+  }
+
+  IrNode visitReturn(Return node) {
+    IrNode value;
+    if (node.expression == null) {
+      if (node.beginToken.value == 'native') return giveup();
+      value = context.enterConstant(constantSystem.createNull(), node);
+    } else {
+      value = node.expression.accept(this);
+    }
+    context.branchReturns();
+    return context.enterStatement(
+        new IrReturn(nodePosition(node), value));
+  }
+
+  IrConstant visitLiteralBool(LiteralBool node) =>
+      context.enterConstant(constantSystem.createBool(node.value), node);
+
+  IrConstant visitLiteralDouble(LiteralDouble node) =>
+      context.enterConstant(constantSystem.createDouble(node.value), node);
+
+  IrConstant visitLiteralInt(LiteralInt node) =>
+      context.enterConstant(constantSystem.createInt(node.value), node);
+
+  IrConstant visitLiteralString(LiteralString node) =>
+      context.enterConstant(
+          constantSystem.createString(node.dartString, node), node);
+
+  IrConstant visitLiteralNull(LiteralNull node) =>
+      context.enterConstant(constantSystem.createNull(), node);
+
+//  IrNode visitLiteralList(LiteralList node) => visitExpression(node);
+//  IrNode visitLiteralMap(LiteralMap node) => visitExpression(node);
+//  IrNode visitLiteralMapEntry(LiteralMapEntry node) => visitNode(node);
+//  IrNode visitLiteralSymbol(LiteralSymbol node) => visitExpression(node);
+
+
+  IrNode visitAssert(Send node) {
+    return giveup();
+  }
+
+  IrNode visitClosureSend(Send node) {
+    return giveup();
+  }
+
+  IrNode visitDynamicSend(Send node) {
+    return giveup();
+  }
+
+  IrNode visitGetterSend(Send node) {
+    return giveup();
+  }
+
+  IrNode visitOperatorSend(Send node) {
+    return giveup();
+  }
+
+  IrNode visitStaticSend(Send node) {
+    return giveup();
+  }
+
+  IrNode visitSuperSend(Send node) {
+    return giveup();
+  }
+
+  IrNode visitTypeReferenceSend(Send node) {
+    return giveup();
+  }
+
+  static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
+
+  IrNode giveup() => throw ABORT_IRNODE_BUILDER;
+
+  void internalError(String reason, {Node node}) {
+    giveup();
+  }
+}
+
+class Context {
+  IrNodeBuilderVisitor visitor;
+  Context(this.visitor);
+
+  List<IrFunction> currentFunctionList = <IrFunction>[];
+  IrFunction get currentFunction => currentFunctionList.last;

[ngeoffray, 2013/11/20 14:55:27]

Actually, we will probably not inline at this level. And currently, the SSA
builder will do it as well.

[lukas, 2013/11/21 12:20:21]

Maybe we want to keep nested functions as such in the IR and translate to
closure classes later? That might simplify some optimizations.

+
+  // TODO(lry): Need to fix this once we actually have branching. The things we
+  // currently achieve with the Conctext class might overlap with LocalHandlers.

[ngeoffray, 2013/11/20 14:55:27]

Conctext -> Context

[lukas, 2013/11/21 12:20:21]

Done.

+  List<bool> returnOnAllBranchesList = <bool>[];
+  bool get returnOnAllBranches => returnOnAllBranchesList.last;
+  void branchReturns() {
+    returnOnAllBranchesList[returnOnAllBranchesList.length - 1] = true;
+  }
+
+  List<List<IrNode>> statementsList = <List<IrNode>>[];
+  List<IrNode> get statements => statementsList.last;
+
+  List<List<IrConstant>> constantsList = <List<IrConstant>>[];
+  List<IrConstant> get constants => constantsList.last;
+
+  IrConstant enterConstant(Constant value, Node node) {

[ngeoffray, 2013/11/20 14:55:27]

Why not a Map of Constant -> IrConstant? Like we have in the SSA.

[lukas, 2013/11/21 12:20:21]

Done.

+    return constants.firstWhere((c) => c.value == value, orElse: () {
+      IrConstant c = new IrConstant(visitor.nodePosition(node), value);
+      constants.add(c);
+      return c;
+    });
+  }
+
+  IrNode enterStatement(IrNode statement) {
+    statements.add(statement);
+    return statement;
+  }
+
+  void openFunction(IrFunction function) {
+    currentFunctionList.add(function);
+    statementsList.add(<IrNode>[]);
+    returnOnAllBranchesList.add(false);
+    constantsList.add(<IrConstant>[]);
+  }
+
+  void closeFunction() {
+    currentFunctionList.removeLast();
+    statementsList.removeLast();
+    returnOnAllBranchesList.removeLast();
+    constantsList.removeLast();
+  }
+
+  void openContinuation() {

[ngeoffray, 2013/11/20 14:55:27]

Unused.

[lukas, 2013/11/21 12:20:21]

Done.

+    statementsList.add(<IrNode>[]);
+  }
+
+  void closeContinuation() {

[ngeoffray, 2013/11/20 14:55:27]

Unused.

[lukas, 2013/11/21 12:20:21]

Done.

+    statementsList.removeLast();
+  }
+
+  isTopLevel() => currentFunctionList.isEmpty;
+}