dart2js: Start creating IR nodes in the IrBuilderVisitor class.

pkg/compiler/lib/src/cps_ir/cps_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 '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
@@ skipping 635 matching lines @@
       _current = _current.plug(expr);
     }
   }
 
   /// Create and add a new [LetPrim] for [primitive].
   ir.Primitive addPrimitive(ir.Primitive primitive) {
     add(new ir.LetPrim(primitive));
     return primitive;
   }
 
-  ir.Primitive _buildInvokeStatic(Element element,
-                                  Selector selector,
-                                  List<ir.Primitive> arguments,
-                                  SourceInformation sourceInformation) {
+  ir.Primitive buildInvokeStatic(Element element,
+                                 Selector selector,
+                                 List<ir.Primitive> arguments,
+                                 SourceInformation sourceInformation) {
     assert(!element.isLocal);
     assert(!element.isInstanceMember);
     assert(isOpen);
     return addPrimitive(
         new ir.InvokeStatic(element, selector, arguments, sourceInformation));
   }
 
   ir.Primitive _buildInvokeSuper(Element target,
                                  Selector selector,
                                  List<ir.Primitive> arguments,
@@ skipping 20 matching lines @@
                                 TypeMask mask,
                                 List<ir.Definition> arguments,
                                 {SourceInformation sourceInformation}) {
     Selector selector = callStructure.callSelector;
     return _buildInvokeDynamic(
         target, selector, mask, arguments, sourceInformation);
   }
 
   ir.Primitive buildStaticNoSuchMethod(Selector selector,
                                        List<ir.Primitive> arguments) {
-    Element thrower = program.throwNoSuchMethod;
     ir.Primitive receiver = buildStringConstant('');
     ir.Primitive name = buildStringConstant(selector.name);
     ir.Primitive argumentList = buildListLiteral(null, arguments);
     ir.Primitive expectedArgumentNames = buildNullConstant();
     return buildStaticFunctionInvocation(
-        thrower,
-        new CallStructure.unnamed(4),
-        [receiver, name, argumentList, expectedArgumentNames]);
+        program.throwNoSuchMethod,
+        <ir.Primitive>[receiver, name, argumentList, expectedArgumentNames]);
   }
 
-
   /// Create a [ir.Constant] from [value] and add it to the CPS term.
   ir.Constant buildConstant(ConstantValue value,
                             {SourceInformation sourceInformation}) {
     assert(isOpen);
     return addPrimitive(
         new ir.Constant(value, sourceInformation: sourceInformation));
   }
 
   /// Create an integer constant and add it to the CPS term.
   ir.Constant buildIntegerConstant(int value) {
@@ skipping 297 matching lines @@
       LocalFunctionElement function,
       CallStructure callStructure,
       List<ir.Primitive> arguments,
       SourceInformation sourceInformation) {
     // TODO(johnniwinther): Maybe this should have its own ir node.
     return buildCallInvocation(
         buildLocalFunctionGet(function), callStructure, arguments,
         sourceInformation: sourceInformation);
   }
 
-  /// Create a static invocation of [function] where argument structure is
-  /// defined by [callStructure] and the argument values are defined by
-  /// [arguments].
+  /// Create a static invocation of [function].
+  ///
+  /// The arguments are not named and their values are defined by [arguments].
   ir.Primitive buildStaticFunctionInvocation(
       MethodElement function,
-      CallStructure callStructure,
       List<ir.Primitive> arguments,
       {SourceInformation sourceInformation}) {
-    Selector selector =
-        new Selector(SelectorKind.CALL, function.memberName, callStructure);
-    return _buildInvokeStatic(
-        function, selector, arguments, sourceInformation);
+    Selector selector = new Selector.call(
+        function.memberName, new CallStructure(arguments.length));
+    return buildInvokeStatic(function, selector, arguments, sourceInformation);
   }
 
   /// Create a read access of the static [field].
   ir.Primitive buildStaticFieldGet(FieldElement field,
                                    SourceInformation sourceInformation) {
     return addPrimitive(new ir.GetStatic(field, sourceInformation));
   }
 
   /// Create a read access of a static [field] that might not have been
   /// initialized yet.
   ir.Primitive buildStaticFieldLazyGet(FieldElement field,
                                        SourceInformation sourceInformation) {
     return addPrimitive(new ir.GetLazyStatic(field, sourceInformation));
   }
 
   /// Create a getter invocation of the static [getter].
   ir.Primitive buildStaticGetterGet(MethodElement getter,
                                     SourceInformation sourceInformation) {
     Selector selector = new Selector.getter(getter.memberName);
-    return _buildInvokeStatic(
+    return buildInvokeStatic(
         getter, selector, const <ir.Primitive>[], sourceInformation);
   }
 
   /// Create a read access of the static [function], i.e. a closurization of
   /// [function].
   ir.Primitive buildStaticFunctionGet(MethodElement function,
                                       {SourceInformation sourceInformation}) {
     return addPrimitive(new ir.GetStatic(function, sourceInformation));
   }
 
   /// Create a write access to the static [field] with the [value].
   ir.Primitive buildStaticFieldSet(FieldElement field,
                                    ir.Primitive value,
                                    [SourceInformation sourceInformation]) {
     addPrimitive(new ir.SetStatic(field, value, sourceInformation));
     return value;
   }
 
   /// Create a setter invocation of the static [setter] with the [value].
   ir.Primitive buildStaticSetterSet(MethodElement setter,
                                     ir.Primitive value,
                                     {SourceInformation sourceInformation}) {
     Selector selector = new Selector.setter(setter.memberName);
-    _buildInvokeStatic(
+    buildInvokeStatic(
         setter, selector, <ir.Primitive>[value], sourceInformation);
     return value;
   }
 
   /// Create an erroneous invocation where argument structure is defined by
   /// [selector] and the argument values are defined by [arguments].
   // TODO(johnniwinther): Make this more fine-grained.
   ir.Primitive buildErroneousInvocation(
       Element element,
       Selector selector,
       List<ir.Primitive> arguments) {
     // TODO(johnniwinther): This should have its own ir node.
-    return _buildInvokeStatic(element, selector, arguments, null);
+    return buildInvokeStatic(element, selector, arguments, null);
   }
 
-  /// Concatenate string values.
-  ///
-  /// The arguments must be strings; usually a call to [buildStringify] is
-  /// needed to ensure the proper conversion takes places.
+  /// Concatenate string values.  The arguments must be strings.
   ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments,
                                         {SourceInformation sourceInformation}) {
     assert(isOpen);
     return addPrimitive(new ir.ApplyBuiltinOperator(
         ir.BuiltinOperator.StringConcatenate,
         arguments,
         sourceInformation));
   }
 
   /// Create an invocation of the `call` method of [functionExpression], where
@@ skipping 578 matching lines @@
 
       ir.Primitive condition = buildConditionsFrom(0)(casesBuilder);
       IrBuilder thenBuilder = makeDelimitedBuilder();
       caseInfo.buildBody(thenBuilder);
       if (thenBuilder.isOpen) {
         // It is a runtime error to reach the end of a switch case, unless
         // it is the last case.
         if (caseInfo == cases.last && defaultCase == null) {
           thenBuilder.jumpTo(join);
         } else {
-          ir.Primitive exception = thenBuilder._buildInvokeStatic(
+          ir.Primitive exception = thenBuilder.buildInvokeStatic(
               error,
               new Selector.fromElement(error),
               <ir.Primitive>[],
               sourceInformation);
           thenBuilder.buildThrow(exception);
         }
       }
 
       ir.Continuation thenContinuation = new ir.Continuation([]);
       thenContinuation.body = thenBuilder._root;
@@ skipping 353 matching lines @@
     //   where (C', x) = Build(e, C)
     //
     // Return without a subexpression is translated as if it were return null.
     assert(isOpen);
     if (value == null) {
       value = buildNullConstant();
     }
     jumpTo(state.returnCollector, value, sourceInformation);
   }
 
-  /// Build a call to the closure conversion helper for the [Function] typed
-  /// value in [value].
-  ir.Primitive _convertDartClosure(ir.Primitive value, FunctionType type) {
-    ir.Constant arity = buildIntegerConstant(type.computeArity());
-    return buildStaticFunctionInvocation(
-        program.closureConverter,
-        CallStructure.TWO_ARGS,
-        <ir.Primitive>[value, arity]);
-  }
-
   /// Generate the body for a native function [function] that is annotated with
   /// an implementation in JavaScript (provided as string in [javaScriptCode]).
   void buildNativeFunctionBody(FunctionElement function,
                                String javaScriptCode) {
     NativeBehavior behavior = new NativeBehavior();
     behavior.sideEffects.setAllSideEffects();
     // Generate a [ForeignCode] statement from the given native code.
     buildForeignCode(
         js.js.statementTemplateYielding(
             new js.LiteralStatement(javaScriptCode)),
@@ skipping 21 matching lines @@
     }
     // Collect all parameters of the function and templates for them to be
     // inserted into the JavaScript code.
     List<String> argumentTemplates = <String>[];
     function.functionSignature.forEachParameter((ParameterElement parameter) {
       ir.Primitive input = environment.lookup(parameter);
       DartType type = program.unaliasType(parameter.type);
       if (type is FunctionType) {
         // The parameter type is a function type either directly or through
         // typedef(s).
-        input = _convertDartClosure(input, type);
+        ir.Constant arity = buildIntegerConstant(type.computeArity());
+        input = buildStaticFunctionInvocation(
+            program.closureConverter, <ir.Primitive>[input, arity]);
       }
       arguments.add(input);
       argumentTemplates.add('#');
     });
     // Construct the application of parameters for functions and setters.
     if (function.kind == ElementKind.FUNCTION) {
       code = "$code(${argumentTemplates.join(', ')})";
     } else if (function.kind == ElementKind.SETTER) {
       code = "$code = ${argumentTemplates.single}";
     } else {
@@ skipping 456 matching lines @@
 
   ir.Primitive buildSuperFieldGet(FieldElement target) {
     return addPrimitive(new ir.GetField(buildThis(), target));
   }
 
   ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value) {
     addPrimitive(new ir.SetField(buildThis(), target, value));
     return value;
   }
 
-  ir.Primitive buildInvokeDirectly(MethodElement target,
-                                   ir.Primitive receiver,
-                                   List<ir.Primitive> arguments,
-                                   {SourceInformation sourceInformation}) {
-    assert(isOpen);
-    Selector selector =
-        new Selector.call(target.memberName, new CallStructure(arguments.length));
-    return addPrimitive(new ir.InvokeMethodDirectly(
-        receiver, target, selector, arguments, sourceInformation));
-  }
-
   /// Loads parameters to a constructor body into the environment.
   ///
   /// The header for a constructor body differs from other functions in that
   /// some parameters are already boxed, and the box is passed as an argument
   /// instead of being created in the header.
   void buildConstructorBodyHeader(Iterable<Local> parameters,
                                   ClosureScope closureScope) {
     _createThisParameter();
     for (Local param in parameters) {
       ir.Parameter parameter = _createLocalParameter(param);
@@ skipping 121 matching lines @@
   /// Creates a type test or type cast of [value] against [type].
   ir.Primitive buildTypeOperator(ir.Primitive value,
                                  DartType type,
                                  {bool isTypeTest}) {
     assert(isOpen);
     assert(isTypeTest != null);
 
     type = program.unaliasType(type);
 
     if (type.isMalformed) {
-      FunctionElement helper = program.throwTypeErrorHelper;
       ErroneousElement element = type.element;
       ir.Primitive message = buildStringConstant(element.message);
       return buildStaticFunctionInvocation(
-          helper,
-          CallStructure.ONE_ARG,
+          program.throwTypeErrorHelper,
           <ir.Primitive>[message]);
     }
 
     List<ir.Primitive> typeArguments = const <ir.Primitive>[];
     if (type is GenericType && type.typeArguments.isNotEmpty) {
       typeArguments = type.typeArguments.map(buildTypeExpression).toList();
     } else if (type is TypeVariableType) {
       typeArguments = <ir.Primitive>[buildTypeVariableAccess(type)];
     } else if (type is FunctionType) {
       typeArguments = <ir.Primitive>[buildTypeExpression(type)];
@@ skipping 45 matching lines @@
     return buildConditional(condition, (_) => receiver, buildSend);
   }
 
   /// Creates a type test checking whether [value] is null.
   ir.Primitive _buildCheckNull(ir.Primitive value,
                                {SourceInformation sourceInformation}) {
     assert(isOpen);
     return buildIdentical(value, buildNullConstant(),
         sourceInformation: sourceInformation);
   }
-
-  /// Convert the given value to a string.
-  ir.Primitive buildStringify(ir.Primitive value) {
-    return buildStaticFunctionInvocation(
-        program.stringifyFunction,
-        new CallStructure.unnamed(1),
-        <ir.Primitive>[value]);
-  }
-
-  ir.Primitive buildAwait(ir.Primitive value) {
-    return addPrimitive(new ir.Await(value));
-  }
-
-  void buildYield(ir.Primitive value, bool hasStar) {
-    addPrimitive(new ir.Yield(value, hasStar));
-  }
-
-  ir.Primitive buildRefinement(ir.Primitive value, TypeMask type) {
-    return addPrimitive(new ir.Refinement(value, type));
-  }
 }
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
   /// If `null`, then the location is [field] on the enclosing function object.
   final closure.BoxLocal box;
 
@@ skipping 91 matching lines @@
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
 }