Revert "Towards compiling Hello World!" and "Compile and run Hello World!"

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:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 23 matching lines @@
 import '../universe/use.dart' show DynamicUse;
 import '../universe/world_builder.dart' show CodegenWorldBuilder;
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart';
 import 'kernel_ast_adapter.dart';
 import 'kernel_string_builder.dart';
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
-import 'ssa.dart';
 import 'ssa_branch_builder.dart';
 import 'switch_continue_analysis.dart';
 import 'type_builder.dart';
 
-class KernelSsaBuilder extends ir.Visitor
-    with GraphBuilder, SsaBuilderFieldMixin {
+class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   final ir.Node target;
   final bool _targetIsConstructorBody;
   final MemberEntity targetElement;
 
   /// The root node of [targetElement]. This is used as the key into the
   /// [startFunction] of the locals handler.
   // TODO(johnniwinther,efortuna): Avoid the need for AST nodes in the locals
   // handler.
   final Node functionNode;
   final ClosedWorld closedWorld;
@@ skipping 72 matching lines @@
   CommonElements get _commonElements => _elementMap.commonElements;
 
   HGraph build() {
     return reporter.withCurrentElement(localsMap.currentMember, () {
       // TODO(het): no reason to do this here...
       HInstruction.idCounter = 0;
       if (target is ir.Procedure) {
         _targetFunction = (target as ir.Procedure).function;
         buildFunctionNode(_targetFunction);
       } else if (target is ir.Field) {
-        if (handleConstantField(targetElement, registry, closedWorld)) {
-          // No code is generated for `targetElement`: All references inline the
-          // constant value.
-          return null;
-        } else if (targetElement.isStatic || targetElement.isTopLevel) {
-          backend.constants.registerLazyStatic(targetElement);
-        }
         buildField(target);
       } else if (target is ir.Constructor) {
         if (_targetIsConstructorBody) {
           buildConstructorBody(target);
         } else {
           buildConstructor(target);
         }
       } else if (target is ir.FunctionExpression) {
         _targetFunction = (target as ir.FunctionExpression).function;
         buildFunctionNode(_targetFunction);
       } else if (target is ir.FunctionDeclaration) {
         _targetFunction = (target as ir.FunctionDeclaration).function;
         buildFunctionNode(_targetFunction);
       } else {
         throw 'No case implemented to handle target: '
             '$target for $targetElement';
       }
       assert(graph.isValid());
       return graph;
     });
   }
 
-  @override
-  ConstantValue getFieldInitialConstantValue(FieldEntity field) {
-    assert(field == targetElement);
-    return _elementMap.getFieldConstantValue(target);
-  }
-
   void buildField(ir.Field field) {
     openFunction();
     if (field.initializer != null) {
       field.initializer.accept(this);
       HInstruction fieldValue = pop();
       HInstruction checkInstruction = typeBuilder.potentiallyCheckOrTrustType(
           fieldValue, _getDartTypeIfValid(field.type));
       stack.add(checkInstruction);
     } else {
       stack.add(graph.addConstantNull(closedWorld));
@@ skipping 1114 matching lines @@
       loopEntryBlock.postProcessLoopHeader();
       SubGraph bodyGraph = new SubGraph(loopEntryBlock, bodyExitBlock);
       HLoopBlockInformation loopBlockInfo = new HLoopBlockInformation(
           HLoopBlockInformation.DO_WHILE_LOOP,
           null,
           wrapExpressionGraph(conditionExpression),
           wrapStatementGraph(bodyGraph),
           null,
           loopEntryBlock.loopInformation.target,
           loopEntryBlock.loopInformation.labels,
-          // TODO(johnniwinther): Provide source information like:
-          // sourceInformationBuilder.buildLoop(astAdapter.getNode(doStatement))
-          null);
+          sourceInformationBuilder.buildLoop(astAdapter.getNode(doStatement)));
       loopEntryBlock.setBlockFlow(loopBlockInfo, current);
       loopInfo.loopBlockInformation = loopBlockInfo;
     } else {
       // Since the loop has no back edge, we remove the loop information on the
       // header.
       loopEntryBlock.loopInformation = null;
 
       if (jumpHandler.hasAnyBreak()) {
         // Null branchBlock because the body of the do-while loop always aborts,
         // so we never get to the condition.
@@ skipping 121 matching lines @@
 
   /// Creates a [JumpHandler] for a statement. The node must be a jump
   /// target. If there are no breaks or continues targeting the statement,
   /// a special "null handler" is returned.
   ///
   /// [isLoopJump] is true when the jump handler is for a loop. This is used
   /// to distinguish the synthesized loop created for a switch statement with
   /// continue statements from simple switch statements.
   JumpHandler createJumpHandler(ir.TreeNode node, {bool isLoopJump: false}) {
     JumpTarget target = localsMap.getJumpTarget(node);
+    assert(target is KernelJumpTarget);
     if (target == null) {
       // No breaks or continues to this node.
       return new NullJumpHandler(reporter);
     }
     if (isLoopJump && node is ir.SwitchStatement) {
       return new KernelSwitchCaseJumpHandler(this, target, node, localsMap);
     }
 
     return new JumpHandler(this, target);
   }
@@ skipping 1141 matching lines @@
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     ir.Node argument = invocation.arguments.positional.first;
     argument.accept(this);
     HInstruction instruction = pop();
 
     if (instruction is HConstant) {
       js.Name name =
-          _elementMap.getNameForJsGetName(instruction.constant, namer);
+          astAdapter.getNameForJsGetName(argument, instruction.constant);
       stack.add(graph.addConstantStringFromName(name, closedWorld));
       return;
     }
 
     reporter.reportErrorMessage(
         _elementMap.getSpannable(targetElement, argument),
         MessageKind.GENERIC,
         {'text': 'Error: Expected a JsGetName enum value.'});
     // Result expected on stack.
     stack.add(graph.addConstantNull(closedWorld));
@@ skipping 31 matching lines @@
     }
 
     List<ir.Expression> arguments = invocation.arguments.positional;
     ir.Expression nameArgument = arguments[1];
 
     nameArgument.accept(this);
     HInstruction instruction = pop();
 
     js.Template template;
     if (instruction is HConstant) {
-      template =
-          _elementMap.getJsBuiltinTemplate(instruction.constant, emitter);
+      template = astAdapter.getJsBuiltinTemplate(instruction.constant);
     }
     if (template == null) {
       reporter.reportErrorMessage(
           _elementMap.getSpannable(targetElement, nameArgument),
           MessageKind.GENERIC,
           {'text': 'Error: Expected a JsBuiltin enum value.'});
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
@@ skipping 43 matching lines @@
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
     ir.Expression argument = invocation.arguments.positional.single;
     argument.accept(this);
     HInstruction argumentInstruction = pop();
     if (argumentInstruction is HConstant) {
       ConstantValue argumentConstant = argumentInstruction.constant;
       if (argumentConstant is TypeConstantValue &&
-          argumentConstant.representedType is InterfaceType) {
-        InterfaceType type = argumentConstant.representedType;
+          argumentConstant.representedType is ResolutionInterfaceType) {
+        ResolutionInterfaceType type = argumentConstant.representedType;
         // TODO(sra): Check that type is a subclass of [Interceptor].
         ConstantValue constant = new InterceptorConstantValue(type.element);
         HInstruction instruction = graph.addConstant(constant, closedWorld);
         stack.add(instruction);
         return;
       }
     }
 
     reporter.reportErrorMessage(
         _elementMap.getSpannable(targetElement, invocation),
@@ skipping 302 matching lines @@
 
     // TODO(sra): For JS-interop targets, process arguments differently.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
     ConstructorEntity constructor = _elementMap.getConstructor(target);
     ClassEntity cls = constructor.enclosingClass;
     if (backend.rtiNeed.classNeedsRti(cls)) {
       _addTypeArguments(arguments, invocation.arguments);
     }
     TypeMask typeMask = new TypeMask.nonNullExact(cls, closedWorld);
-    InterfaceType type = _elementMap.createInterfaceType(
-        target.enclosingClass, invocation.arguments.types);
-    addImplicitInstantiation(type);
     _pushStaticInvocation(constructor, arguments, typeMask);
-    removeImplicitInstantiation(type);
   }
 
   @override
   void visitIsExpression(ir.IsExpression isExpression) {
     isExpression.operand.accept(this);
     HInstruction expression = pop();
     pushIsTest(isExpression, isExpression.type, expression);
   }
 
   void pushIsTest(ir.Node node, ir.DartType type, HInstruction expression) {
@@ skipping 419 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }