Generate code that throws an exception on unimplemented features.

dart/frog/leg/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 311 matching lines @@
   }
 
   /**
    * Returns an [HInstruction] for the given element. If the element is
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
   HInstruction readLocal(Element element) {
     if (isAccessedDirectly(element)) {
       if (directLocals[element] == null) {
-        builder.compiler.internalError("Cannot find value", element: element);
+        builder.compiler.internalError("Cannot find value $element",
+                                       element: element);
       }
       return directLocals[element];
     } else if (isStoredInClosureField(element)) {
       Element redirect = redirectionMapping[element];
       // We must not use the [LocalsHandler.readThis()] since that could
       // point to a captured this which would be stored in a closure-field
       // itself.
       HInstruction receiver = new HThis();
       builder.add(receiver);
       HInstruction fieldGet = new HFieldGet(redirect, receiver);
@@ skipping 1718 matching lines @@
     }  else {
       breakInstruction = new HBreak(node.target.source);
     }
     close(breakInstruction);
     handler.addBreak(breakInstruction, savedLocals);
   }
 
   visitContinueStatement(ContinueStatement node) {
     // TODO(lrn): Replace this with a real implementation of continue.
     compiler.reportWarning(node, 'continue not implemented');
-    DartString string = new DartString.literal('continue not implemented');
-    HInstruction message = graph.addNewLiteralString(string);
-    close(new HThrow(message));
+    generateUnimplemented('continue not implemented');
   }
 
   BreakHandler getLoopBreakHandler(Loop node) {
     StatementElement element = elements[node];
     BreakHandler handler;
     if (loopBreakHandler === null) {
       if (element === null) return const NullBreakHandler();
       handler = new BreakHandler(this, element);
     } else {
       handler = loopBreakHandler;
@@ skipping 128 matching lines @@
       // Mark both entry and exit with the information. You can
       // tell which one is which by comparing with blockInfo.start/end.
       // It doesn't matter which merge block we use, they won't be generating
       // any code, so put the end-marker on the last join block.
       entryBlock.labeledBlockInformation = blockInfo;
       current.labeledBlockInformation = blockInfo;
     }
   }
 
   visitLiteralMap(LiteralMap node) {
-    compiler.unimplemented('SsaBuilder.visitLiteralMap', node: node);
+    generateUnimplemented('literal map not implemented', isExpression: true);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     compiler.unimplemented('SsaBuilder.visitLiteralMapEntry', node: node);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
-    compiler.unimplemented('SsaBuilder.visitSwitchStatement', node: node);
+    generateUnimplemented('switch statement not implemented');
   }
 
   visitTryStatement(TryStatement node) {
     work.allowSpeculativeOptimization = false;
     assert(!work.isBailoutVersion());
     HBasicBlock enterBlock = graph.addNewBlock();
     close(new HGoto()).addSuccessor(enterBlock);
     open(enterBlock);
     HTry tryInstruction = new HTry();
     List<HBasicBlock> blocks = <HBasicBlock>[];
@@ skipping 89 matching lines @@
     compiler.unimplemented('SsaBuilder.visitScriptTag', node: node);
   }
 
   visitCatchBlock(CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
+
+  generateUnimplemented(String reason, [bool isExpression = false]) {
+    DartString string = new DartString.literal(reason);
+    HInstruction message = graph.addNewLiteralString(string);
+
+    // Normally, we would call [close] here. However, then we hit
+    // another unimplemented feature: aborting loop body. Simply
+    // calling [add] does not work as it asserts that the instruction
+    // isn't a control flow instruction. So we inline parts of [add].
+    current.addAfter(current.last, new HThrow(message));
+    if (isExpression) {
+      stack.add(graph.addNewLiteralNull());
+    }
+  }
 }