implement kernel -> ssa for literals

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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 'package:compiler/src/constants/values.dart';
+import 'package:compiler/src/diagnostics/invariant.dart';
 import 'package:kernel/ast.dart' as ir;
 
-import '../common/codegen.dart' show CodegenWorkItem;
+import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
 import '../diagnostics/spannable.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../kernel/kernel_visitor.dart';
 import '../resolution/tree_elements.dart';
+import '../tree/tree.dart' as ast;
 import 'graph_builder.dart';
 import 'locals_handler.dart';
 import 'nodes.dart';
 
 class SsaKernelBuilderTask extends CompilerTask {
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA kernel builder';
 
@@ skipping 11 matching lines @@
       try {
         function = visitor.buildFunction();
       } catch (e) {
         throw "Failed to convert to Kernel IR: $e";
       }
       KernelSsaBuilder builder = new KernelSsaBuilder(
           function,
           element,
           work.resolvedAst,
           backend.compiler,
+          work.registry,
           sourceInformationFactory,
-          visitor.nodeToElement);
+          visitor.nodeToElement,
+          visitor.nodeToAst);
       return builder.build();
     });
   }
 }
 
 class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   final IrFunction function;
   final FunctionElement functionElement;
   final ResolvedAst resolvedAst;
   final Compiler compiler;
+  final CodegenRegistry registry;
   final Map<ir.Node, Element> nodeToElement;
+  final Map<ir.Node, ast.Node> nodeToAst;
 
   JavaScriptBackend get backend => compiler.backend;
 
   LocalsHandler localsHandler;
   SourceInformationBuilder sourceInformationBuilder;
 
   KernelSsaBuilder(
       this.function,
       this.functionElement,
       this.resolvedAst,
       this.compiler,
+      this.registry,
       SourceInformationStrategy sourceInformationFactory,
-      this.nodeToElement) {
+      this.nodeToElement,
+      this.nodeToAst) {
     graph.element = functionElement;
     // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
     this.sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler =
         new LocalsHandler(this, functionElement, null, compiler);
   }
 
@@ skipping 27 matching lines @@
     close(new HGoto()).addSuccessor(block);
 
     open(block);
   }
 
   void closeFunction() {
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
   }
 
+  ConstantValue getConstantForNode(ast.Node node) {

[Siggi Cherem (dart-lang), 2016/08/26 18:15:57]

Let's create a library and a class with the ir->ast abstractions, so the code
here would contain no import to tree.dart.

For example:
class Kernel2AstAdapter {
  constantValueForSymbol(ir.SymbolLiteral node); // internally accesses node +
resolvedAst to get the right data.
}

[Harry Terkelsen, 2016/08/26 19:52:57]

Done.

+    ConstantValue constantValue =
+        backend.constants.getConstantValueForNode(node, resolvedAst.elements);
+    assert(invariant(node, constantValue != null,
+        message: 'No constant computed for $node'));
+    return constantValue;
+  }
+
   @override
   void visitBlock(ir.Block block) {
     assert(!isAborted());
     for (ir.Statement statement in block.statements) {
       statement.accept(this);
       if (!isReachable) {
         // The block has been aborted by a return or a throw.
         if (stack.isNotEmpty) {
           compiler.reporter.internalError(
               NO_LOCATION_SPANNABLE, 'Non-empty instruction stack.');
@@ skipping 21 matching lines @@
     // TODO(het): Add source information
     // TODO(het): Set a return value instead of closing the function when we
     // support inlining.
     closeAndGotoExit(new HReturn(value, null));
   }
 
   @override
   void visitIntLiteral(ir.IntLiteral intLiteral) {
     stack.add(graph.addConstantInt(intLiteral.value, compiler));
   }
+
+  @override
+  visitDoubleLiteral(ir.DoubleLiteral doubleLiteral) {
+    stack.add(graph.addConstantDouble(doubleLiteral.value, compiler));
+  }
+
+  @override
+  visitBoolLiteral(ir.BoolLiteral boolLiteral) {
+    stack.add(graph.addConstantBool(boolLiteral.value, compiler));
+  }
+
+  @override
+  visitStringLiteral(ir.StringLiteral stringLiteral) {
+    stack.add(graph.addConstantString(
+        new ast.DartString.literal(stringLiteral.value), compiler));

[Siggi Cherem (dart-lang), 2016/08/26 18:15:57]

for now because DartString is pretty independent of the rest of the ast, it's
less of an issue IMO to have that dependency, but we can in the future create
the constant directly from the string value (e.g. using `new
StringConstantValue.fromString`).

For now, if we move the rest to the Kernel2ASTAdapter, let's update the import
above to import `tree/dart_string.dart` instead of `tree.dart`.

[Harry Terkelsen, 2016/08/26 19:52:58]

Done.

+  }
+
+  @override
+  visitSymbolLiteral(ir.SymbolLiteral symbolLiteral) {
+    stack.add(graph.addConstant(
+        getConstantForNode(nodeToAst[symbolLiteral]), compiler));
+    registry?.registerConstSymbol(symbolLiteral.value);
+  }
+
+  @override
+  visitNullLiteral(ir.NullLiteral nullLiteral) {
+    stack.add(graph.addConstantNull(compiler));
+  }
 }