Generate a warning and a runtime error for calls to nonexistent static calls, getters and setters.

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 1990 matching lines @@
           push(new HInvokeStatic(<HInstruction>[pop()]));
         }
       }
     } else if (Elements.isInstanceSend(send, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceGetterWithCompiledReceiver(send, receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       push(new HStatic(element));
       // TODO(ahe): This should be registered in codegen.
       compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
+    } else if (element != null && Element.isInvalid(element)) {
+      // An erroneous element indicates an unresolved static getter.

[kasperl, 2012/09/05 09:29:45]

Introduce new helper for this? Moar code sharing for the win.

[karlklose, 2012/09/05 11:10:47]

Done.

+      ErroneousElement error = element;
+      Message message = error.errorMessage;
+      String name = 'get ${message.arguments[0]}';
+      generateThrowNoSuchMethod(send, name, const EmptyLink<Node>());
     } else {
       stack.add(localsHandler.readLocal(element));
     }
   }
 
   void generateInstanceSetterWithCompiledReceiver(Send send,
                                                   HInstruction receiver,
                                                   HInstruction value) {
     assert(Elements.isInstanceSend(send, elements));
     Selector selector = elements.getSelector(send);
@@ skipping 20 matching lines @@
         HStatic target = new HStatic(element);
         add(target);
         add(new HInvokeStatic(<HInstruction>[target, value]));
       } else {
         add(new HStaticStore(element, value));
       }
       stack.add(value);
     } else if (element === null || Elements.isInstanceField(element)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceSetterWithCompiledReceiver(send, receiver, value);
+    } else if (element != null && Element.isInvalid(element)) {
+      // An erroneous element indicates an unresolved static getter.
+      ErroneousElement error = element;
+      Message message = error.errorMessage;
+      String name = 'set ${message.arguments[0]}';
+      generateThrowNoSuchMethod(send, name, 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);
       if (checked !== value) {
         pop();
         stack.add(checked);
@@ skipping 540 matching lines @@
     });
 
     HType elementType = computeType(constructor);
     HInstruction newInstance = new HInvokeStatic(inputs, elementType);
     pushWithPosition(newInstance, node);
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
+    if (element.isErroneous()) {
+      ErroneousElement error = element;
+      String name = error.errorMessage.arguments[0].toString();
+      generateThrowNoSuchMethod(node, name, node.arguments);
+      return;
+    }
     if (element === compiler.assertMethod && !compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull());
       return;
     }
     compiler.ensure(element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR);
 
     if (tryInlineMethod(element, selector, node.arguments)) return;
 
     HInstruction target = new HStatic(element);
     add(target);
@@ skipping 35 matching lines @@
     compiler.internalError(reason, node: node);
   }
 
   void generateRuntimeError(Node node, String message) {
     DartString messageObject = new DartString.literal(message);
     HInstruction errorMessage = graph.addConstantString(messageObject, node);
     Element helper = interceptors.getThrowRuntimeError();
     pushInvokeHelper1(helper, errorMessage);
   }
 
+  void generateThrowNoSuchMethod(Node diagnosticNode,
+                                 String methodName,
+                                 [Link<Node> argumentNodes,
+                                  List<HInstruction> argumentValues]) {
+    Element helper =
+        compiler.findHelper(const SourceString('throwNoSuchMethod'));
+    HInstruction receiver =
+        graph.addConstantString(new DartString.empty(), diagnosticNode);
+    DartString dartString = new DartString.literal(methodName);
+    HInstruction name = graph.addConstantString(dartString, diagnosticNode);
+    if (argumentValues == null) {
+      argumentValues = <HInstruction>[];
+      argumentNodes.forEach((argumentNode) {
+        visit(argumentNode);
+        HInstruction value = pop();
+        argumentValues.add(value);
+      });
+    }
+    HInstruction arguments = new HLiteralList(argumentValues);
+    add(arguments);
+    pushInvokeHelper3(helper, receiver, name, arguments);
+  }
+
   visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
     if (element != null && element.isErroneous()) {
       ErroneousElement error = element;
       Message message = error.errorMessage;
       if (message.kind === MessageKind.CANNOT_FIND_CONSTRUCTOR) {
-        Element helper =
-            compiler.findHelper(const SourceString('throwNoSuchMethod'));
-        DartString receiverLiteral = new DartString.literal('');
-        HInstruction receiver = graph.addConstantString(receiverLiteral, node);
         String constructorName = 'constructor ${message.arguments[0]}';
-        DartString nameLiteral = new DartString.literal(constructorName);
-        HInstruction name = graph.addConstantString(nameLiteral, node.send);
-        List<HInstruction> inputs = <HInstruction>[];
-        node.send.arguments.forEach((argumentNode) {
-          visit(argumentNode);
-          HInstruction value = pop();
-          inputs.add(value);
-        });
-        HInstruction arguments = new HLiteralList(inputs);
-        add(arguments);
-        pushInvokeHelper3(helper, receiver, name, arguments);
+        generateThrowNoSuchMethod(node.send, constructorName,
+                                  node.send.arguments);
       } else if (message.kind === MessageKind.CANNOT_RESOLVE) {
         generateRuntimeError(node.send, message.message);
       } else {
         compiler.internalError('unexpected unresolved constructor call',
                                node: node);
       }
     } else if (node.isConst()) {
       // TODO(karlklose): add type representation
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
@@ skipping 349 matching lines @@
       push(new HInvokeDynamicMethod(call, <HInstruction>[iterator]));
 
       Element variable;
       if (node.declaredIdentifier.asSend() !== null) {
         variable = elements[node.declaredIdentifier];
       } else {
         assert(node.declaredIdentifier.asVariableDefinitions() !== null);
         VariableDefinitions variableDefinitions = node.declaredIdentifier;
         variable = elements[variableDefinitions.definitions.nodes.head];
       }
-      localsHandler.updateLocal(variable, pop());
+      HInstruction oldVariable = pop();
+      if (variable == null) {
+      } else if (variable.isErroneous()) {

[kasperl, 2012/09/05 09:29:45]

Add a comment in the empty braces to make it clear that this is intentional.

[karlklose, 2012/09/05 11:10:47]

Done.

+        ErroneousElement error = variable;
+        String name = 'setter ${error.errorMessage.arguments[0]}';
+        generateThrowNoSuchMethod(node, name,
+                                  argumentValues: <HInstruction>[oldVariable]);
+        pop();
+      } else {
+        localsHandler.updateLocal(variable, oldVariable);
+      }
 
       visit(node.body);
     }
     handleLoop(node, buildInitializer, buildCondition, () {}, buildBody);
   }
 
   visitLabel(Label node) {
     compiler.internalError('SsaBuilder.visitLabel', node: node);
   }
 
@@ skipping 933 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;
   }
 }