dart2js: Start creating IR nodes in the IrBuilderVisitor class.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_task;
 
 import '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
@@ skipping 452 matching lines @@
       irBuilder.add(new ir.LetPrim(instance));
 
       // --- Call constructor bodies ---
       for (ConstructorElement target in constructorList) {
         ConstructorBodyElement bodyElement = getConstructorBody(target);
         if (bodyElement == null) continue; // Skip if constructor has no body.
         List<ir.Primitive> bodyArguments = <ir.Primitive>[];
         for (Local param in getConstructorBodyParameters(bodyElement)) {
           bodyArguments.add(irBuilder.environment.lookup(param));
         }
-        irBuilder.buildInvokeDirectly(bodyElement, instance, bodyArguments);
+        Selector selector = new Selector.call(target.memberName,
+            new CallStructure(bodyArguments.length));
+        irBuilder.addPrimitive(new ir.InvokeMethodDirectly(
+            instance, bodyElement, selector, bodyArguments, null));
       }
 
       // --- step 4: return the created object ----
       irBuilder.buildReturn(
           value: instance,
           sourceInformation:
           sourceInformationBuilder.buildImplicitReturn(constructor));
 
       return irBuilder.makeFunctionDefinition();
     });
@@ skipping 571 matching lines @@
         target: elements.getTargetDefinition(node),
         closureScope: getClosureScopeForNode(node));
   }
 
   visitAsyncForIn(ast.AsyncForIn node) {
     // await for is not yet implemented.
     return giveup(node, 'await for');
   }
 
   visitAwait(ast.Await node) {
+    assert(irBuilder.isOpen);
     ir.Primitive value = visit(node.expression);
-    return irBuilder.buildAwait(value);
+    return irBuilder.addPrimitive(new ir.Await(value));
   }
 
   visitYield(ast.Yield node) {
+    assert(irBuilder.isOpen);
     ir.Primitive value = visit(node.expression);
-    return irBuilder.buildYield(value, node.hasStar);
+    return irBuilder.addPrimitive(new ir.Yield(value, node.hasStar));
   }
 
   visitSyncForIn(ast.SyncForIn node) {
     // [node.declaredIdentifier] can be either an [ast.VariableDefinitions]
     // (defining a new local variable) or a send designating some existing
     // variable.
     ast.Node identifier = node.declaredIdentifier;
     ast.VariableDefinitions variableDeclaration =
         identifier.asVariableDefinitions();
     Element variableElement = elements.getForInVariable(node);
@@ skipping 14 matching lines @@
   }
 
   /// If compiling with trusted type annotations, assumes that [value] is
   /// now known to be `null` or an instance of [type].
   ///
   /// This is also where we should add type checks in checked mode, but this
   /// is not supported yet.
   ir.Primitive checkType(ir.Primitive value, DartType dartType) {
     if (!compiler.trustTypeAnnotations) return value;
     TypeMask type = typeMaskSystem.subtypesOf(dartType).nullable();
-    return irBuilder.buildRefinement(value, type);
+    return irBuilder.addPrimitive(new ir.Refinement(value, type));
   }
 
   ir.Primitive checkTypeVsElement(ir.Primitive value, TypedElement element) {
     return checkType(value, element.type);
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(irBuilder.isOpen);
     for (ast.Node definition in node.definitions.nodes) {
       Element element = elements[definition];
@@ skipping 267 matching lines @@
   // ## Sends ##
   @override
   void previsitDeferredAccess(ast.Send node, PrefixElement prefix, _) {
     if (prefix != null) buildCheckDeferredIsLoaded(prefix, node);
   }
 
   /// Create a call to check that a deferred import has already been loaded.
   ir.Primitive buildCheckDeferredIsLoaded(PrefixElement prefix, ast.Send node) {
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildCall(node, node.selector);
+    ir.Primitive name = irBuilder.buildStringConstant(
+        compiler.deferredLoadTask.getImportDeferName(node, prefix));
+    ir.Primitive uri =
+        irBuilder.buildStringConstant('${prefix.deferredImport.uri}');
     return irBuilder.buildStaticFunctionInvocation(
         helpers.checkDeferredIsLoaded,
-        CallStructure.TWO_ARGS, <ir.Primitive>[
-          irBuilder.buildStringConstant(
-              compiler.deferredLoadTask.getImportDeferName(node, prefix)),
-          irBuilder.buildStringConstant('${prefix.deferredImport.uri}'),
-        ], sourceInformation: sourceInformation);
+        <ir.Primitive>[name, uri],
+        sourceInformation: sourceInformation);
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   @override
   ir.Primitive visitExpressionInvoke(ast.Send node,
                                      ast.Node expression,
@@ skipping 113 matching lines @@
   /// pseudo-function on library prefixes of deferred imports.
   ir.Primitive buildStaticGetterGet(MethodElement getter, ast.Send node) {
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     if (getter.isDeferredLoaderGetter) {
       PrefixElement prefix = getter.enclosingElement;
       ir.Primitive loadId = irBuilder.buildStringConstant(
           compiler.deferredLoadTask.getImportDeferName(node, prefix));
       return irBuilder.buildStaticFunctionInvocation(
           compiler.loadLibraryFunction,
-          CallStructure.ONE_ARG, <ir.Primitive>[loadId],
+          <ir.Primitive>[loadId],
           sourceInformation: sourceInformation);
     } else {
       return irBuilder.buildStaticGetterGet(getter, sourceInformation);
     }
   }
 
   @override
   ir.Primitive visitSuperFieldGet(
       ast.Send node,
       FieldElement field,
@@ skipping 452 matching lines @@
       MethodElement function,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentsNode, callStructure);
     } else {
       List<ir.Primitive> arguments = <ir.Primitive>[];
       callStructure = translateStaticArguments(argumentsNode, function,
           callStructure, arguments);
-      return irBuilder.buildStaticFunctionInvocation(function,
-          callStructure,
-          arguments,
-          sourceInformation:
+      Selector selector = new Selector.call(function.memberName, callStructure);
+      return irBuilder.buildInvokeStatic(function, selector, arguments,
           sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 
   @override
   ir.Primitive handleStaticFunctionIncompatibleInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
@@ skipping 760 matching lines @@
     /// its own isolate structure, that encapsulates dart2js's isolate.
     ir.Primitive buildIsolateHelperInvocation(Element element,
         CallStructure callStructure) {
       if (element == null) {
         reporter.internalError(node,
             'Isolate library and compiler mismatch.');
       }
       List<ir.Primitive> arguments = <ir.Primitive>[];
       callStructure = translateStaticArguments(argumentList, element,
           callStructure, arguments);
-      return irBuilder.buildStaticFunctionInvocation(
-          element,
-          callStructure,
-          arguments,
-          sourceInformation:
+      Selector selector = new Selector.call(element.memberName, callStructure);
+      return irBuilder.buildInvokeStatic(element, selector, arguments,
           sourceInformationBuilder.buildCall(node, node.selector));
     }
 
     /// Lookup the value of the enum described by [node].
     getEnumValue(ast.Node node, EnumClassElement enumClass, List values) {
       Element element = elements[node];
       if (element is! FieldElement || element.enclosingClass != enumClass) {
         internalError(node, 'expected a JsBuiltin enum value');
       }
 
@@ skipping 200 matching lines @@
     } else if (node is ast.LiteralString) {
       // Empty strings often occur at the end of a string interpolation,
       // do not bother to include them.
       if (!node.dartString.isEmpty) {
         accumulator.add(irBuilder.buildDartStringConstant(node.dartString));
       }
     } else if (node is ast.ParenthesizedExpression) {
       buildStringParts(node.expression, accumulator);
     } else {
       ir.Primitive value = visit(node);
-      accumulator.add(irBuilder.buildStringify(value));
+      accumulator.add(irBuilder.buildStaticFunctionInvocation(
+          helpers.stringInterpolationHelper,
+          <ir.Primitive>[value]));
     }
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(irBuilder.isOpen);
     List<ir.Primitive> parts = <ir.Primitive>[];
     buildStringParts(node, parts);
     return irBuilder.buildStringConcatenation(parts);
   }
 
@@ skipping 21 matching lines @@
   ir.Primitive buildInstanceNoSuchMethod(Selector selector,
       TypeMask mask,
       List<ir.Primitive> arguments) {
     return irBuilder.buildDynamicInvocation(
         irBuilder.buildThis(),
         Selectors.noSuchMethod_,
         mask,
         [irBuilder.buildInvocationMirror(selector, arguments)]);
   }
 
-  ir.Primitive buildRuntimeError(String message) {
-    return irBuilder.buildStaticFunctionInvocation(
-        helpers.throwRuntimeError,
-        new CallStructure.unnamed(1),
-        [irBuilder.buildStringConstant(message)]);
-  }
-
-  ir.Primitive buildAbstractClassInstantiationError(ClassElement element) {
-    return irBuilder.buildStaticFunctionInvocation(
-        helpers.throwAbstractClassInstantiationError,
-        new CallStructure.unnamed(1),
-        [irBuilder.buildStringConstant(element.name)]);
-  }
-
   @override
   ir.Primitive visitUnresolvedCompound(
       ast.Send node,
       Element element,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     // TODO(asgerf): What is unresolved? The getter and/or the setter?
     //               If it was the setter, we must evaluate the right-hand side.
     return irBuilder.buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
   ir.Primitive visitUnresolvedClassConstructorInvoke(
       ast.NewExpression node,
       Element element,
       DartType type,
       ast.NodeList arguments,
       Selector selector, _) {
     // If the class is missing it's a runtime error.
-    return buildRuntimeError("Unresolved class: '${element.name}'");
+    ir.Primitive message =
+        irBuilder.buildStringConstant("Unresolved class: '${element.name}'");
+    return irBuilder.buildStaticFunctionInvocation(
+        helpers.throwRuntimeError,
+        <ir.Primitive>[message]);
   }
 
   @override
   ir.Primitive visitUnresolvedConstructorInvoke(
       ast.NewExpression node,
       Element constructor,
       DartType type,
       ast.NodeList argumentsNode,
       Selector selector, _) {
     // If the class is there but the constructor is missing, it's an NSM error.
@@ skipping 146 matching lines @@
   }
 
   @override
   ir.Primitive visitAbstractClassConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement element,
       InterfaceType type,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     for (ast.Node argument in arguments) visit(argument);
-    return buildAbstractClassInstantiationError(element.enclosingClass);
+    ir.Primitive name =
+        irBuilder.buildStringConstant(element.enclosingClass.name);
+    return irBuilder.buildStaticFunctionInvocation(
+        helpers.throwAbstractClassInstantiationError,
+        <ir.Primitive>[name]);
   }
 
   @override
   ir.Primitive handleFinalStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     // TODO(asgerf): Include class name somehow for static class members?
     return irBuilder.buildStaticNoSuchMethod(
         new Selector.setter(field.memberName),
@@ skipping 321 matching lines @@
   JavaScriptBackend get _backend => _compiler.backend;
 
   GlobalProgramInformation(this._compiler);
 
   /// Returns [true], if the analysis could not determine that the type
   /// arguments for the class [cls] are never used in the program.
   bool requiresRuntimeTypesFor(ClassElement cls) {
     return cls.typeVariables.isNotEmpty && _backend.classNeedsRti(cls);
   }
 
-  FunctionElement get stringifyFunction {
-    return _backend.helpers.stringInterpolationHelper;
-  }
-
   FunctionElement get throwTypeErrorHelper => _backend.helpers.throwTypeError;
   Element get throwNoSuchMethod => _backend.helpers.throwNoSuchMethod;
 
   ClassElement get nullClass => _compiler.coreClasses.nullClass;
 
   DartType unaliasType(DartType type) => type.unaliased;
 
   TypeMask getTypeMaskForForeign(NativeBehavior behavior) {
     if (behavior == null) {
       return _backend.dynamicType;
     }
     return TypeMaskFactory.fromNativeBehavior(behavior, _compiler);
   }
 
   FieldElement locateSingleField(Selector selector, TypeMask type) {
     return _compiler.world.locateSingleField(selector, type);
   }
 
   Element get closureConverter {
     return _backend.helpers.closureConverter;
   }
 
   void addNativeMethod(FunctionElement function) {
     _backend.emitter.nativeEmitter.nativeMethods.add(function);
   }
 }