Support checked mode for return type.

sdk/lib/_internal/compiler/implementation/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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 906 matching lines @@
       sourceElementStack = <Element>[work.element],
       inliningStack = <InliningState>[],
       rti = builder.compiler.codegenWorld.rti,
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this);
   }
 
   static const MAX_INLINING_DEPTH = 3;
   static const MAX_INLINING_SOURCE_SIZE = 128;
   List<InliningState> inliningStack;
-  Element returnElement = null;
+  Element returnElement;
+  DartType returnType;
 
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
     methodInterceptionEnabled = false;
   }
 
   void enableMethodInterception() {
     assert(!methodInterceptionEnabled);
     methodInterceptionEnabled = true;
   }
@@ skipping 14 matching lines @@
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     SendSet node = variable.parseNode(compiler);
     openFunction(variable, node);
     Link<Node> link = node.arguments;
     assert(!link.isEmpty && link.tail.isEmpty);
     visit(link.head);
     HInstruction value = pop();
-    value = potentiallyCheckType(value, variable);
+    value = potentiallyCheckType(value, variable.computeType(compiler));
     close(new HReturn(value)).addSuccessor(graph.exit);
     return closeFunction();
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
@@ skipping 56 matching lines @@
     // Once we start to compile the arguments we must be sure that we don't
     // abort.
     List<HInstruction> compiledArguments = new List<HInstruction>();
     bool succeeded = addStaticSendArgumentsToList(selector,
                                                   arguments,
                                                   function,
                                                   compiledArguments);
     assert(succeeded);
 
     InliningState state =
-        new InliningState(function, returnElement, elements, stack);
+        new InliningState(function, returnElement, returnType, elements, stack);
     inliningStack.add(state);
     sourceElementStack.add(function);
     stack = <HInstruction>[];
     returnElement = new Element(const SourceString("result"),
                                 ElementKind.VARIABLE,
                                 function);
     localsHandler.updateLocal(returnElement,
                               graph.addConstantNull(constantSystem));
     elements = compiler.enqueuer.resolution.getCachedElements(function);
     assert(elements != null);
     FunctionSignature signature = function.computeSignature(compiler);
+    returnType = signature.returnType;
     int index = 0;
     signature.orderedForEachParameter((Element parameter) {
       HInstruction argument = compiledArguments[index++];
       localsHandler.updateLocal(parameter, argument);
-      potentiallyCheckType(argument, parameter);
+      potentiallyCheckType(argument, parameter.computeType(compiler));
     });
     return state;
   }
 
   void leaveInlinedMethod(InliningState state) {
     InliningState poppedState = inliningStack.removeLast();
     assert(state == poppedState);
     FunctionElement poppedElement = sourceElementStack.removeLast();
     assert(poppedElement == poppedState.function);
     elements = state.oldElements;
     stack.add(localsHandler.readLocal(returnElement));
     returnElement = state.oldReturnElement;
+    returnType = state.oldReturnType;
     assert(stack.length == 1);
     state.oldStack.add(stack[0]);
     stack = state.oldStack;
   }
 
   /**
    * Documentation wanted -- johnniwinther
    */
   bool tryInlineMethod(Element element,
                        Selector selector,
@@ skipping 261 matching lines @@
 
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
     List<FunctionElement> constructors = <FunctionElement>[functionElement];
     buildInitializers(functionElement, constructors, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
-          constructorArguments.add(
-              potentiallyCheckType(fieldValues[member], member));
+          constructorArguments.add(potentiallyCheckType(
+              fieldValues[member], member.computeType(compiler)));
         },
         includeBackendMembers: true,
         includeSuperMembers: true);
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
 
     // Create the runtime type information, if needed.
     InterfaceType type = classElement.computeType(compiler);
     List<HInstruction> inputs = <HInstruction>[];
@@ skipping 128 matching lines @@
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(element, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
-      FunctionSignature params = functionElement.computeSignature(compiler);
-      params.orderedForEachParameter((Element parameterElement) {
+      FunctionSignature signature = functionElement.computeSignature(compiler);
+      signature.orderedForEachParameter((Element parameterElement) {
         if (elements.isParameterChecked(parameterElement)) {
           addParameterCheckInstruction(parameterElement);
         }
       });
 
       // Put the type checks in the first successor of the entry,
       // because that is where the type guards will also be inserted.
       // This way we ensure that a type guard will dominate the type
       // check.
-      params.orderedForEachParameter((Element element) {
+      signature.orderedForEachParameter((Element element) {
         HInstruction newParameter = potentiallyCheckType(
-            localsHandler.directLocals[element], element);
+            localsHandler.directLocals[element],
+            element.computeType(compiler));
         localsHandler.directLocals[element] = newParameter;
       });
+
+      returnType = signature.returnType;
     } else {
       // Otherwise it is a lazy initializer which does not have parameters.
       assert(element is VariableElement);
     }
 
     // Add the type parameters of the class as parameters of this
     // method.
     var enclosing = element.enclosingElement;
     if (element.isConstructor() && compiler.world.needsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
         HParameterValue param = new HParameterValue(typeVariable.element);
         add(param);
         localsHandler.directLocals[typeVariable.element] = param;
       });
     }
   }
 
   HInstruction potentiallyCheckType(
-      HInstruction original, Element sourceElement,
+      HInstruction original, DartType type,
       { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
     if (!compiler.enableTypeAssertions) return original;
-    HInstruction other = original.convertType(compiler, sourceElement, kind);
+    HInstruction other = original.convertType(compiler, type, kind);
     if (other != original) add(other);
     return other;
   }
 
   HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
     if (!isAborted()) close(new HGoto()).addSuccessor(graph.exit);
     graph.finalize();
     return graph;
   }
@@ skipping 61 matching lines @@
 
   void dup() {
     stack.add(stack.last);
   }
 
   HInstruction popBoolified() {
     HInstruction value = pop();
     if (compiler.enableTypeAssertions) {
       return potentiallyCheckType(
           value,
-          compiler.boolClass,
+          compiler.boolClass.computeType(compiler),
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value);
     add(result);
     return result;
   }
 
   HInstruction attachPosition(HInstruction target, Node node) {
     target.sourcePosition = sourceFileLocationForBeginToken(node);
     return target;
@@ skipping 662 matching lines @@
     stack.add(value);
   }
 
   void generateSetter(SendSet send, Element element, HInstruction value) {
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter()) {
         HStatic target = new HStatic(element);
         add(target);
         addWithPosition(new HInvokeStatic(<HInstruction>[target, value]), send);
       } else {
-        value = potentiallyCheckType(value, element);
+        value = potentiallyCheckType(value, element.computeType(compiler));
         addWithPosition(new HStaticStore(element, value), send);
       }
       stack.add(value);
     } else if (element == null || Elements.isInstanceField(element)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceSetterWithCompiledReceiver(send, receiver, value);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static setter.
       generateThrowNoSuchMethod(send,
                                 getTargetName(element, 'set'),
                                 argumentNodes: send.arguments);
     } else {
       stack.add(value);
       // If the value does not already have a name, give it here.
       if (value.sourceElement == null) {
         value.sourceElement = element;
       }
-      HInstruction checked = potentiallyCheckType(value, element);
+      HInstruction checked = potentiallyCheckType(
+          value, element.computeType(compiler));
       if (!identical(checked, value)) {
         pop();
         stack.add(checked);
       }
       localsHandler.updateLocal(element, checked);
     }
   }
 
   void pushInvokeHelper0(Element helper) {
     HInstruction reference = new HStatic(helper);
@@ skipping 97 matching lines @@
         }
         push(instruction);
       }
     } else if (const SourceString("as") == op.source) {
       visit(node.receiver);
       HInstruction expression = pop();
       Node argument = node.arguments.head;
       TypeAnnotation typeAnnotation = argument.asTypeAnnotation();
       DartType type = elements.getType(typeAnnotation);
       HInstruction converted = expression.convertType(
-          compiler, type.element, HTypeConversion.CAST_TYPE_CHECK);
+          compiler, type, HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expression) add(converted);
       stack.add(converted);
     } else {
       visit(node.receiver);
       visit(node.argumentsNode);
       var right = pop();
       var left = pop();
       visitBinary(left, op, right);
     }
   }
@@ skipping 997 matching lines @@
     if (node.isRedirectingFactoryBody) {
       compiler.internalError("Unimplemented: Redirecting factory constructor",
                              node: node);
     }
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(constantSystem);
     } else {
       visit(node.expression);
       value = pop();
+      value = potentiallyCheckType(value, returnType);
     }
     if (!inliningStack.isEmpty) {
       localsHandler.updateLocal(returnElement, value);
     } else {
       close(attachPosition(new HReturn(value), node)).addSuccessor(graph.exit);
     }
   }
 
   visitThrow(Throw node) {
     if (node.expression == null) {
@@ skipping 954 matching lines @@
 }
 
 class InliningState {
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
   final PartialFunctionElement function;
   final Element oldReturnElement;
+  final DartType oldReturnType;
   final TreeElements oldElements;
   final List<HInstruction> oldStack;
 
   InliningState(this.function,
                 this.oldReturnElement,
+                this.oldReturnType,
                 this.oldElements,
                 this.oldStack) {
     assert(function.isImplementation);
   }
 }
 
 class SsaBranch {
   final SsaBranchBuilder branchBuilder;
   final HBasicBlock block;
   LocalsHandler startLocals;
@@ skipping 221 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }