Compute default throws behavior from JavaScript.

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

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 224 matching lines @@
   void redirectElement(Local from, CapturedVariable to) {
     assert(redirectionMapping[from] == null);
     redirectionMapping[from] = to;
     assert(isStoredInClosureField(from) || isBoxed(from));
   }
 
   HInstruction createBox() {
     // TODO(floitsch): Clean up this hack. Should we create a box-object by
     // just creating an empty object literal?
     JavaScriptBackend backend = builder.backend;
-    HInstruction box = new HForeignCode(js.js.parseForeignJS('{}'),
-                                        backend.nonNullType,
-                                        <HInstruction>[]);
+    HInstruction box = new HForeignCode(
+        js.js.parseForeignJS('{}'),
+        backend.nonNullType,
+        <HInstruction>[],
+        nativeBehavior: native.NativeBehavior.PURE_ALLOCATION);
     builder.add(box);
     return box;
   }
 
   /**
    * If the scope (function or loop) [node] has captured variables then this
    * method creates a box and sets up the redirections.
    */
   void enterScope(ast.Node node, Element element) {
     // See if any variable in the top-scope of the function is captured. If yes
@@ skipping 3141 matching lines @@
       localsHandler.updateLocal(local, checkedOrTrusted);
     }
   }
 
   HInstruction invokeInterceptor(HInstruction receiver) {
     HInterceptor interceptor = new HInterceptor(receiver, backend.nonNullType);
     add(interceptor);
     return interceptor;
   }
 
-  HForeignCode createForeign(js.Template code,
-                             TypeMask type,
-                             List<HInstruction> inputs) {
-    return new HForeignCode(code, type, inputs);
-  }
-
   HLiteralList buildLiteralList(List<HInstruction> inputs) {
     return new HLiteralList(inputs, backend.extendableArrayType);
   }
 
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   HInstruction buildTypeArgumentRepresentations(DartType type) {
     // Compute the representation of the type arguments, including access
     // to the runtime type information for type variables as instructions.
     if (type.isTypeVariable) {
       return buildLiteralList(<HInstruction>[addTypeVariableReference(type)]);
     } else {
       assert(type.element.isClass);
       InterfaceType interface = type;
       List<HInstruction> inputs = <HInstruction>[];
       bool first = true;
       List<String> templates = <String>[];
       for (DartType argument in interface.typeArguments) {
         templates.add(rti.getTypeRepresentationWithHashes(argument, (variable) {
           HInstruction runtimeType = addTypeVariableReference(variable);
           inputs.add(runtimeType);
         }));
       }
       String template = '[${templates.join(', ')}]';
       // TODO(sra): This is a fresh template each time.  We can't let the
       // template manager build them.
       js.Template code = js.js.uncachedExpressionTemplate(template);
       HInstruction representation =
-        createForeign(code, backend.readableArrayType, inputs);
+          new HForeignCode(code, backend.readableArrayType, inputs,
+              nativeBehavior: native.NativeBehavior.PURE_ALLOCATION);
       return representation;
     }
   }
 
   visitOperatorSend(ast.Send node) {
     ast.Operator op = node.selector;
     if ("[]" == op.source) {
       visitDynamicSend(node);
     } else if ("&&" == op.source ||
                "||" == op.source) {
@@ skipping 193 matching lines @@
     inputs.add(closureTarget);
     addDynamicSendArgumentsToList(node, inputs);
     Selector closureSelector = new Selector.callClosureFrom(selector);
     pushWithPosition(
         new HInvokeClosure(closureSelector, inputs, backend.dynamicType),
         node);
   }
 
   void handleForeignJs(ast.Send node) {
     Link<ast.Node> link = node.arguments;
-    // If the invoke is on foreign code, don't visit the first
-    // argument, which is the type, and the second argument,
-    // which is the foreign code.
+    // Don't visit the first argument, which is the type, and the second
+    // argument, which is the foreign code.
     if (link.isEmpty || link.tail.isEmpty) {
       compiler.internalError(node.argumentsNode,
           'At least two arguments expected.');
     }
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
 
     if (nativeBehavior.codeTemplate.isExpression) {
-      push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
-                            effects: nativeBehavior.sideEffects,
-                            nativeBehavior: nativeBehavior));
+      push(new HForeignCode(
+          nativeBehavior.codeTemplate, ssaType, inputs,
+          effects: nativeBehavior.sideEffects,
+          nativeBehavior: nativeBehavior));
     } else {
-      push(new HForeignCode(nativeBehavior.codeTemplate, ssaType, inputs,
-                            isStatement: true,
-                            effects: nativeBehavior.sideEffects,
-                            nativeBehavior: nativeBehavior,
-                            canThrow: true));
+      push(new HForeignCode(
+          nativeBehavior.codeTemplate, ssaType, inputs,
+          isStatement: true,
+          effects: nativeBehavior.sideEffects,
+          nativeBehavior: nativeBehavior));
     }
   }
 
   void handleJsStringConcat(ast.Send node) {
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(node.arguments, inputs);
     if (inputs.length != 2) {
       compiler.internalError(node.argumentsNode, 'Two arguments expected.');
     }
     push(new HStringConcat(inputs[0], inputs[1], node, backend.stringType));
@@ skipping 138 matching lines @@
     }
     HConstant hConstant = globalNameHNode;
     StringConstantValue constant = hConstant.constant;
     String globalName = constant.primitiveValue.slowToString();
     js.Template expr = js.js.expressionTemplateYielding(
         backend.emitter.generateEmbeddedGlobalAccess(globalName));
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
-    push(new HForeignCode(expr, ssaType, const []));
+    push(new HForeignCode(expr, ssaType, const [],
+            nativeBehavior: nativeBehavior));
   }
 
   void handleJsInterceptorConstant(ast.Send node) {
     // Single argument must be a TypeConstant which is converted into a
     // InterceptorConstant.
     if (!node.arguments.isEmpty && node.arguments.tail.isEmpty) {
       ast.Node argument = node.arguments.head;
       visit(argument);
       HInstruction argumentInstruction = pop();
       if (argumentInstruction is HConstant) {
@@ skipping 51 matching lines @@
     // and implementation signatures. Currently it is need because the
     // signatures have different elements for parameters.
     FunctionElement implementation = function.implementation;
     FunctionSignature params = implementation.functionSignature;
     if (params.optionalParameterCount != 0) {
       compiler.internalError(closure,
           '"$name" does not handle closure with optional parameters.');
     }
 
     registry.registerStaticUse(element);
-    push(new HForeignCode(js.js.expressionTemplateYielding(
-                          backend.emitter.staticFunctionAccess(element)),
-                          backend.dynamicType,
-                          <HInstruction>[]));
+    push(new HForeignCode(
+        js.js.expressionTemplateYielding(
+            backend.emitter.staticFunctionAccess(element)),
+        backend.dynamicType,
+        <HInstruction>[],
+        nativeBehavior: native.NativeBehavior.PURE));
     return params;
   }
 
   void handleForeignDartClosureToJs(ast.Send node, String name) {
     // TODO(ahe): This implements DART_CLOSURE_TO_JS and should probably take
     // care to wrap the closure in another closure that saves the current
     // isolate.
     handleForeignRawFunctionRef(node, name);
   }
 
   void handleForeignSetCurrentIsolate(ast.Send node) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       compiler.internalError(node.argumentsNode,
           'Exactly one argument required.');
     }
     visit(node.arguments.head);
     String isolateName = backend.namer.currentIsolate;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
-    push(new HForeignCode(js.js.parseForeignJS("$isolateName = #"),
-                          backend.dynamicType,
-                          <HInstruction>[pop()],
-                          effects: sideEffects));
+    push(new HForeignCode(
+        js.js.parseForeignJS("$isolateName = #"),
+        backend.dynamicType,
+        <HInstruction>[pop()],
+        nativeBehavior: native.NativeBehavior.PURE,
+        effects: sideEffects));
   }
 
   void handleForeignDartObjectJsConstructorFunction(ast.Send node) {
     if (!node.arguments.isEmpty) {
       compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
-    push(new HForeignCode(js.js.expressionTemplateYielding(
-                          backend.emitter.typeAccess(compiler.objectClass)),
-                          backend.dynamicType,
-                          <HInstruction>[]));
+    push(new HForeignCode(
+        js.js.expressionTemplateYielding(
+            backend.emitter.typeAccess(compiler.objectClass)),
+        backend.dynamicType,
+        <HInstruction>[]));
   }
 
   void handleForeignJsCurrentIsolate(ast.Send node) {
     if (!node.arguments.isEmpty) {
       compiler.internalError(node.argumentsNode, 'Too many arguments.');
     }
     push(new HForeignCode(js.js.parseForeignJS(backend.namer.currentIsolate),
                           backend.dynamicType,
                           <HInstruction>[]));
   }
@@ skipping 311 matching lines @@
       return addTypeVariableReference(argument);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
     String template = rti.getTypeRepresentationWithHashes(argument, (variable) {
       inputs.add(addTypeVariableReference(variable));
     });
 
     js.Template code = js.js.uncachedExpressionTemplate(template);
-    HInstruction result = createForeign(code, backend.stringType, inputs);
+    HInstruction result = new HForeignCode(code, backend.stringType, inputs,
+        nativeBehavior: native.NativeBehavior.PURE);
     add(result);
     return result;
   }
 
   HInstruction handleListConstructor(InterfaceType type,
                                      ast.Node currentNode,
                                      HInstruction newObject) {
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
     }
@@ skipping 146 matching lines @@
       js.Template code = js.js.parseForeignJS('Array(#)');
       var behavior = new native.NativeBehavior();
       behavior.typesReturned.add(expectedType);
       // The allocation can throw only if the given length is a double
       // or negative.
       bool canThrow = true;
       if (inputs[0].isInteger(compiler) && inputs[0] is HConstant) {
         var constant = inputs[0];
         if (constant.constant.primitiveValue >= 0) canThrow = false;
       }
-      HForeignCode foreign = new HForeignCode(
-          code, elementType, inputs, nativeBehavior: behavior,
-          canThrow: canThrow);
+      HForeignCode foreign = new HForeignCode(code, elementType, inputs,
+          nativeBehavior: behavior,
+          throwBehavior: canThrow
+              ? native.NativeThrowBehavior.MAY
+              : native.NativeThrowBehavior.NEVER);
       push(foreign);
       TypesInferrer inferrer = compiler.typesTask.typesInferrer;
       if (inferrer.isFixedArrayCheckedForGrowable(send)) {
         js.Template code = js.js.parseForeignJS(r'#.fixed$length = Array');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
-        add(new HForeignCode(
-              code, backend.nullType, [stack.last], canThrow: true));
+        add(new HForeignCode(code, backend.nullType, [stack.last],
+                throwBehavior: native.NativeThrowBehavior.MAY));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
       ClassElement cls = constructor.enclosingClass;
       if (cls.isAbstract && constructor.isGenerativeConstructor) {
         generateAbstractClassInstantiationError(send, cls.name);
         return;
       }
@@ skipping 1423 matching lines @@
           buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
       // a test of the target.
       void buildCondition() {
         js.Template code = js.js.parseForeignJS('#');
-        push(createForeign(code,
-                           backend.boolType,
-                           [localsHandler.readLocal(switchTarget)]));
+        push(new HForeignCode(
+            code,
+            backend.boolType,
+            [localsHandler.readLocal(switchTarget)],
+            nativeBehavior: native.NativeBehavior.PURE));
       }
       handleIf(node, buildCondition, buildLoop, () => {});
     }
   }
 
   /**
    * Creates a switch statement.
    *
    * [jumpHandler] is the [JumpHandler] for the created switch statement.
    * [buildExpression] creates the switch expression.
@@ skipping 1058 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }