Implement simple dynamic type check.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 105 matching lines @@
     return compiler.findHelper(const SourceString('eq'));
   }
 
   Element getTripleEqualsInterceptor() {
     return compiler.findHelper(const SourceString('eqq'));
   }
 
   Element getMapMaker() {
     return compiler.findHelper(const SourceString('makeLiteralMap'));
   }
+
+  // TODO(karlklose): move these to different class or rename class?
+  Element getSetRuntimeTypeInfo() {
+    return compiler.findHelper(const SourceString('setRuntimeTypeInfo'));
+  }
+
+  Element getGetRuntimeTypeInfo() {
+    return compiler.findHelper(const SourceString('getRuntimeTypeInfo'));
+  }
 }
 
 class SsaBuilderTask extends CompilerTask {
   final Interceptors interceptors;
   final Map<Node, ClosureData> closureDataCache;
 
   String get name() => 'SSA builder';
 
   SsaBuilderTask(Compiler compiler)
     : interceptors = new Interceptors(compiler),
@@ skipping 1647 matching lines @@
       HInstruction expression = pop();
       Node argument = node.arguments.head;
       TypeAnnotation typeAnnotation = argument.asTypeAnnotation();
       bool isNot = false;
       // TODO(ngeoffray): Duplicating pattern in resolver. We should
       // add a new kind of node.
       if (typeAnnotation == null) {
         typeAnnotation = argument.asSend().receiver;
         isNot = true;
       }
+
       Type type = elements.getType(typeAnnotation);
+      HInstruction typeInfo = null;
+      if (compiler.universe.rti.hasTypeArguments(type)) {
+        HInstruction typeInfoGetter =
+            new HStatic(interceptors.getGetRuntimeTypeInfo());
+        add(typeInfoGetter);
+        typeInfo = new HInvokeStatic(Selector.INVOCATION_1,
+                                     <HInstruction>[typeInfoGetter, expression]);

[kasperl, 2012/04/30 08:48:32]

Line too long.

[ngeoffray, 2012/04/30 08:51:12]

line too long

[karlklose, 2012/05/01 11:20:55]

Done.

[karlklose, 2012/05/01 11:20:55]

Done.

+        add(typeInfo);
+      }
       if (type.element.kind === ElementKind.TYPE_VARIABLE) {
         // TODO(karlklose): We emulate the frog behavior and answer
         // true to any is check involving a type variable -- both is T
         // and is !T -- until we have a proper implementation of
         // reified generics.
         stack.add(graph.addConstantBool(true));
       } else {
-        HInstruction instruction = new HIs(type, expression);
+        HInstruction instruction;
+        if (compiler.universe.rti.hasTypeArguments(type)) {

[kasperl, 2012/04/30 08:48:32]

Change this check to typeInfo != null?

[karlklose, 2012/05/01 11:20:55]

Done.

+          instruction = new HIs.withTypeInfo(type, expression, typeInfo);
+        } else {
+          instruction = new HIs(type, expression);
+        }
         if (isNot) {
           add(instruction);
           instruction = new HNot(instruction);
         }
         push(instruction);
       }
     } else {
       visit(node.receiver);
       visit(node.argumentsNode);
       var right = pop();
@@ skipping 334 matching lines @@
       push(new HInvokeSuper(selector, inputs));
     } else {
       target = new HInvokeSuper(Selector.GETTER, inputs);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
 
+  visitNewSend(Send node) {
+    Selector selector = elements.getSelector(node);
+    Element element = elements[node];
+    compiler.resolver.resolveMethodElement(element);
+    FunctionElement functionElement = element;
+    element = functionElement.defaultImplementation;
+    HInstruction target = new HStatic(element);
+    add(target);
+    var inputs = <HInstruction>[];
+    inputs.add(target);
+    bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
+                                                  element, inputs);
+    if (!succeeded) {
+      // TODO(ngeoffray): Match the VM behavior and throw an
+      // exception at runtime.
+      compiler.cancel('Unimplemented non-matching static call', node: node);
+    }
+
+    HType elementType = HType.UNKNOWN;

[kasperl, 2012/04/30 08:48:32]

Factor out the computation of elementType?

[karlklose, 2012/05/01 11:20:55]

Done.

+    Element originalElement = elements[node];
+    if (originalElement.enclosingElement === compiler.listClass) {
+      if (node.arguments.isEmpty()) {
+        elementType = HType.EXTENDABLE_ARRAY;
+      } else {
+        elementType = HType.MUTABLE_ARRAY;
+      }
+    } else if (element.isGenerativeConstructor()) {
+      ClassElement cls = element.enclosingElement;
+      elementType = new HNonPrimitiveType(cls.type);
+    }
+    HInstruction newInstance = new HInvokeStatic(selector, inputs, elementType);
+    push(newInstance);
+
+    TypeAnnotation annotation = getTypeAnnotationFromSend(node);
+    Type type = elements.getType(annotation);
+
+    if (compiler.universe.rti.hasTypeArguments(type)) {

[kasperl, 2012/04/30 08:48:32]

Factor out the code in this if?

[karlklose, 2012/05/01 11:20:55]

Done.

+      String typeString = compiler.universe.rti.asJsString(type);
+      HInstruction typeInfo = new HForeign(new LiteralDartString(typeString),
+                                           new LiteralDartString('Object'),
+                                           <HInstruction>[]);
+      add(typeInfo);
+
+      HInstruction typeInfoSetter =
+          new HStatic(interceptors.getSetRuntimeTypeInfo());
+      add(typeInfoSetter);
+      Selector setSelector = Selector.INVOCATION_2;
+      add(new HInvokeStatic(setSelector,
+                            <HInstruction>[typeInfoSetter, newInstance,
+                            typeInfo]));
+    }
+  }
+
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
-    if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
-      compiler.resolver.resolveMethodElement(element);
-      FunctionElement functionElement = element;
-      element = functionElement.defaultImplementation;
-    }
+    compiler.ensure(element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR);
     HInstruction target = new HStatic(element);
     add(target);
     var inputs = <HInstruction>[];
     inputs.add(target);
-    if (element.kind == ElementKind.FUNCTION ||
-        element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
+    if (element.kind == ElementKind.FUNCTION) {
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element, inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented non-matching static call', node: node);
       }
-      HType type = HType.UNKNOWN;
-      Element originalElement = elements[node];
-      if (originalElement.isGenerativeConstructor()
-          && originalElement.enclosingElement === compiler.listClass) {
-        if (node.arguments.isEmpty()) {
-          type = HType.EXTENDABLE_ARRAY;
-        } else {
-          type = HType.MUTABLE_ARRAY;
-        }
-      } else if (element.isGenerativeConstructor()) {
-        ClassElement cls = element.enclosingElement;
-        type = new HNonPrimitiveType(cls.type);
-      }
-      push(new HInvokeStatic(selector, inputs, type));
+      push(new HInvokeStatic(selector, inputs));
     } else {
       if (element.kind == ElementKind.GETTER) {
         target = new HInvokeStatic(Selector.GETTER, inputs);
         add(target);
         inputs = <HInstruction>[target];
       }
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
@@ skipping 27 matching lines @@
         // Example: A.f() or f() with 'f' bound to a static function.
         // Also includes new A() or new A.named() which is treated like a
         // static call to a factory.
         visitStaticSend(node);
       } else {
         compiler.internalError("Cannot generate code for send", node: node);
       }
     }
   }
 
+  // TODO(karlklose): share with resolver.
+  TypeAnnotation getTypeAnnotationFromSend(Send send) {
+    if (send.selector.asTypeAnnotation() !== null) {

[kasperl, 2012/04/30 08:48:32]

I wonder if it wouldn't be cleaner with is checks here?

   send.selector is TypeAnnotation

[karlklose, 2012/05/01 11:20:55]

Changed to is-checks.

+      return send.selector;
+    } else if (send.selector.asSend() !== null) {
+      Send selector = send.selector;
+      if (selector.receiver.asTypeAnnotation() !== null) {
+        return selector.receiver;
+      }
+    } else {
+      compiler.internalError("malformed send in new expression");

[kasperl, 2012/04/30 08:48:32]

Do we usually start our error messages with a capital letter?

[karlklose, 2012/05/01 11:20:55]

We use both variants.

+    }
+  }
+
   visitNewExpression(NewExpression node) {
     if (node.isConst()) {
+      // TODO(karlklose): add type representation
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
       stack.add(graph.addConstant(constant));
     } else {
-      visitSend(node.send);
+      visitNewSend(node.send);
     }
   }
 
   visitSendSet(SendSet node) {
     Operator op = node.assignmentOperator;
     if (node.isSuperCall) {
       compiler.unimplemented('super property store', node: node);
     } else if (node.isIndex) {
       if (!methodInterceptionEnabled) {
         assert(op.source.stringValue === '=');
@@ skipping 879 matching lines @@
                                         <HInstruction>[target, input],
                                         HType.STRING));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }