Reduce usage of buildUnsupported.

lib/kernel_visitor.dart

 // Copyright (c) 2016, 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.md file.
 
 library rasta.kernel_visitor;
 
 import 'package:kernel/ast.dart' as ir;
 
 import 'package:kernel/accessors.dart' show
     Accessor,
@@ skipping 345 matching lines @@
       return new ir.InvalidExpression();
     }
   }
 
   @override
   ir.InvalidExpression handleUnresolved(Node node) {
     return new ir.InvalidExpression();
   }
 
   @override
-  ir.Throw handleError(Node node) {
-    return buildUnsupported(node, "handleError");
-  }
+  ir.Expression handleError(Node node) => new ir.InvalidExpression();
 
   @override
   void apply(Node node, _) {
     throw new Unsupported("Not implemented yet.");
   }
 
   @override
   void previsitDeferredAccess(Send node, PrefixElement prefix, _) {
   }
 
@@ skipping 321 matching lines @@
     assert(startLength == cascadeReceivers.length);
     return new ir.Let(receiverVariable, result);
   }
 
   @override
   ir.VariableGet visitCascadeReceiver(CascadeReceiver node) {
     return cascadeReceivers.remove(node);
   }
 
   @override
-  ir.Throw visitCaseMatch(CaseMatch node) {
-    return buildUnsupported(node, "CaseMatch");
+  visitCaseMatch(CaseMatch node) {
+    // Shouldn't be called. Handled by [visitSwitchCase].
+    return internalError(node, "CaseMatch");
   }
 
   @override
   ir.Catch visitCatchBlock(CatchBlock node) {
     ir.VariableDeclaration exception =
         (node.exception == null) ? null : getLocal(elements[node.exception]);
     ir.VariableDeclaration trace =
         (node.trace == null) ? null : getLocal(elements[node.trace]);
     ir.DartType guard = computeType(node.type);
     return new ir.Catch(
@@ skipping 97 matching lines @@
   ir.Statement visitIf(If node) {
     return buildContinueAndBreakTarget(
         new ir.IfStatement(
             visitForValue(node.condition),
             buildStatementInBlock(node.thenPart),
             buildStatementInBlock(node.elsePart)),
         node, elements.getTargetDefinition(node));
   }
 
   @override
-  ir.Throw visitLabel(Label node) {
-    return buildUnsupported(node, "Label");
+  visitLabel(Label node) {
+    // Shouldn't be called. Handled by visitLabeledStatement and
+    // visitSwitchCase.
+    return internalError(node, "Label");
   }
 
   @override
   ir.Statement visitLabeledStatement(LabeledStatement node) {
     Statement statement = node.statement;
     ir.Statement result = (statement is Block)
         // If [statement] is a Block, we need to ensure that we don't bypass
         // its visit method (so it can build break targets correctly).
         ? statement.accept(this)
         : buildStatementInBlock(statement);
@@ skipping 60 matching lines @@
     }
     List<ir.DartType> typeArguments =
         computeTypesFromTypes(node.typeArguments, expected: 2);
     return new ir.MapLiteral(
         entries, keyType: typeArguments.first, valueType: typeArguments.last,
         // TODO(ahe): Should Constness be validated?
         isConst: node.isConst);
   }
 
   @override
-  ir.Throw visitLiteralMapEntry(LiteralMapEntry node) {
-    return buildUnsupported(node, "LiteralMapEntry");
+  visitLiteralMapEntry(LiteralMapEntry node) {
+    // Shouldn't be called. Handled by [visitLiteralMap].
+    return internalError(node, "LiteralMapEntry");
   }
 
   @override
   ir.NullLiteral visitLiteralNull(LiteralNull node) {
     return new ir.NullLiteral();
   }
 
   @override
   ir.Expression visitLiteralString(LiteralString node) {
     if (node.dartString == null) return new ir.InvalidExpression();
     return new ir.StringLiteral(node.dartString.slowToString());
   }
 
   @override
   ir.SymbolLiteral visitLiteralSymbol(LiteralSymbol node) {
     return new ir.SymbolLiteral(node.slowNameString);
   }
 
   @override
-  ir.Throw visitMetadata(Metadata node) {
-    return buildUnsupported(node, "Metadata");
+  visitMetadata(Metadata node) {
+    // Shouldn't be called. Metadata should already have been analyzed and
+    // converted to a constant expression in the resolver.
+    return internalError(node, "Metadata not handled as constant.");
   }
 
   @override
   ir.NamedExpression visitNamedArgument(NamedArgument node) {
     return new ir.NamedExpression(
         node.name.source, visitForValue(node.expression));
   }
 
   @override
-  ir.Throw visitOperator(Operator node) {
-    return buildUnsupported(node, "Operator");
+  visitOperator(Operator node) {
+    // This is a special subclass of [Identifier], and we should never see that
+    // in the semantic visitor.
+    return internalError(node, "Operator");
   }
 
   @override
   ir.Expression visitParenthesizedExpression(ParenthesizedExpression node) {
     return visitWithCurrentContext(node.expression);
   }
 
   @override
-  ir.Throw visitRedirectingFactoryBody(RedirectingFactoryBody node) {
-    return buildUnsupported(node, "RedirectingFactoryBody");
+  visitRedirectingFactoryBody(RedirectingFactoryBody node) {
+    // Not implemented yet.
+    return internalError(node, "RedirectingFactoryBody");
   }
 
   @override
   ir.ExpressionStatement visitRethrow(Rethrow node) {
     return new ir.ExpressionStatement(new ir.Rethrow());
   }
 
   @override
   ir.ReturnStatement visitReturn(Return node) {
     return new ir.ReturnStatement(visitForValue(node.expression));
@@ skipping 97 matching lines @@
     }
     if (node.finallyBlock != null) {
       result =
           new ir.TryFinally(result, buildStatementInBlock(node.finallyBlock));
     }
     return buildContinueAndBreakTarget(
         result, node, elements.getTargetDefinition(node));
   }
 
   @override
-  ir.Throw visitTypeAnnotation(TypeAnnotation node) {
-    return buildUnsupported(node, "TypeAnnotation");
+  visitTypeAnnotation(TypeAnnotation node) {
+    // Shouldn't be called, as the resolver have already resolved types and
+    // created [DartType] objects.
+    return internalError(node, "TypeAnnotation");
   }
 
   @override
-  ir.Throw visitTypeVariable(TypeVariable node) {
-    return buildUnsupported(node, "TypeVariable");
+  visitTypeVariable(TypeVariable node) {
+    // Shouldn't be called, as the resolver have already resolved types and
+    // created [DartType] objects.
+    return internalError(node, "TypeVariable");
   }
 
   @override
   ir.Statement visitWhile(While node) {
     ir.Expression condition = visitForValue(node.condition);
     JumpTarget jumpTarget = elements.getTargetDefinition(node);
     ir.Statement body = buildContinueTarget(
         buildStatementInBlock(node.body), node, jumpTarget);
     return buildBreakTarget(
         new ir.WhileStatement(condition, body), node, jumpTarget);
@@ skipping 513 matching lines @@
       SendSet node,
       Node receiver,
       Name name,
       Node rhs,
       _) {
     return buildNullAwarePropertyAccessor(receiver, name).buildAssignment(
         visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
-  ir.Throw visitIfNotNullDynamicPropertySetIfNull(
+  ir.Expression visitIfNotNullDynamicPropertySetIfNull(
       Send node,
       Node receiver,
       Name name,
       Node rhs,
       _) {
     return buildNullAwarePropertyAccessor(receiver, name)
         .buildNullAwareAssignment(
             visitForValue(rhs), voidContext: isVoidContext);
   }
 
@@ skipping 88 matching lines @@
   ir.Initializer visitInitializingFormalDeclaration(
       VariableDefinitions node,
       Node definition,
       InitializingFormalElement parameter,
       int index,
       _) {
     return buildInitializingFormal(parameter);
   }
 
   @override
-  ir.Throw visitInstanceFieldDeclaration(
+  visitInstanceFieldDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       Node initializer,
       _) {
-    return buildUnsupported(node, "InstanceFieldDeclaration");
+    // Shouldn't be called, handled by fieldToIr.
+    return internalError(node, "InstanceFieldDeclaration");
   }
 
   @override
   IrFunction visitInstanceGetterDeclaration(
       FunctionExpression node,
       MethodElement getter,
       Node body,
       _) {
     return buildIrFunction(ir.ProcedureKind.Getter, getter, body);
   }
@@ skipping 148 matching lines @@
   ir.Initializer visitNamedInitializingFormalDeclaration(
       VariableDefinitions node,
       Node definition,
       InitializingFormalElement parameter,
       ConstantExpression defaultValue,
       _) {
     return buildInitializingFormal(parameter);
   }
 
   @override
-  ir.Throw visitNamedParameterDeclaration(
+  visitNamedParameterDeclaration(
       VariableDefinitions node,
       Node definition,
       ParameterElement parameter,
       ConstantExpression defaultValue,
       _) {
-    return buildUnsupported(node, "NamedParameterDeclaration");
+    // Shouldn't be called, we handle parameters via [FunctionSignture].
+    return internalError(node, "NamedParameterDeclaration");
   }
 
   @override
   ir.Not visitNot(Send node, Node expression, _) {
     return new ir.Not(visitForValue(expression));
   }
 
   @override
   ir.Not visitNotEquals(Send node, Node left, Node right, _) {
     return new ir.Not(buildBinaryOperator(left, '==', right));
   }
 
   @override
   ir.Initializer visitOptionalInitializingFormalDeclaration(
       VariableDefinitions node,
       Node definition,
       InitializingFormalElement parameter,
       ConstantExpression defaultValue,
       int index,
       _) {
     return buildInitializingFormal(parameter);
   }
 
   @override
-  ir.Throw visitOptionalParameterDeclaration(
+  visitOptionalParameterDeclaration(
       VariableDefinitions node,
       Node definition,
       ParameterElement parameter,
       ConstantExpression defaultValue,
       int index,
       _) {
-    return buildUnsupported(node, "OptionalParameterDeclaration");
+    // Shouldn't be called, we handle parameters via [FunctionSignture].
+    return internalError(node, "OptionalParameterDeclaration");
   }
 
   @override
-  ir.Throw visitParameterDeclaration(
+  visitParameterDeclaration(
       VariableDefinitions node,
       Node definition,
       ParameterElement parameter,
       int index,
       _) {
-    return buildUnsupported(node, "ParameterDeclaration");
+    // Shouldn't be called, we handle parameters via [FunctionSignture].
+    return internalError(node, "ParameterDeclaration");
   }
 
   @override
   ir.MethodInvocation handleLocalInvoke(
       Send node,
       LocalElement element,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildCall(buildLocalGet(element), callStructure, arguments);
@@ skipping 27 matching lines @@
           <ir.Initializer>[new ir.InvalidInitializer()]);
     }
     ir.Statement body = null;
     if (kernel.isSyntheticError(redirectionTarget)) {
       body = new ir.InvalidStatement();
     } else {
       // TODO(ahe): This should be implemented, but doesn't matter much unless
       // we support reflection. At the call-site, we bypass this factory and
       // call its effective target directly. So this factory is only necessary
       // for reflection.
-      body = new ir.ExpressionStatement(
-          buildUnsupported(node, "redirecting factory constructor body."));
+      body = new ir.InvalidStatement();
     }
     IrFunction function =
         buildIrFunction(ir.ProcedureKind.Factory, constructor, null);
     function.node.body = body..parent = function.node;
     return function;
   }
 
   @override
   ir.Expression visitRedirectingFactoryConstructorInvoke(
       NewExpression node,
@@ skipping 29 matching lines @@
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildGenerativeConstructorInvoke(
         constructor, arguments, isConst: false);
   }
 
   @override
-  ir.Throw visitStaticConstantDeclaration(
+  visitStaticConstantDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       ConstantExpression constant,
       _) {
-    // Should not normally be called, handled by fieldToIr.
+    // Shouldn't be called, handled by fieldToIr.
     return internalError(node, "StaticConstantDeclaration");
   }
 
   @override
-  ir.Throw visitStaticFieldDeclaration(
+  visitStaticFieldDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       Node initializer,
       _) {
-    // Should not normally be called, handled by fieldToIr.
+    // Shouldn't be called, handled by fieldToIr.
     return internalError(node, "StaticFieldDeclaration");
   }
 
   ir.Expression buildStaticGet(Element element) {
     return buildStaticAccessor(element).buildSimpleRead();
   }
 
   @override
   ir.Expression handleStaticFieldGet(Send node, FieldElement field, _) {
     return buildStaticGet(field);
@@ skipping 205 matching lines @@
       _) {
     return buildIrFunction(ir.ProcedureKind.Getter, getter, body);
   }
 
   @override
   ir.Expression handleStaticGetterGet(
       Send node,
       FunctionElement getter,
       _) {
     if (getter.isDeferredLoaderGetter) {
-      return buildUnsupported(node, "deferred access");
+      // TODO(ahe): Support deferred load.
+      return new ir.InvalidExpression();
     }
     return buildStaticGet(getter);
   }
 
   @override
   ir.Expression handleStaticGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     if (getter.isDeferredLoaderGetter) {
-      return buildUnsupported(node, "deferred access");
+      // TODO(ahe): Support deferred load.
+      return new ir.InvalidExpression();
     }
     return buildCall(buildStaticGet(getter), callStructure, arguments);
   }
 
   @override
   ir.Expression handleStaticGetterSet(
       SendSet node,
       FunctionElement getter,
       Node rhs,
       _) {
@@ skipping 423 matching lines @@
         new ir.ThisExpression(), selector, buildArguments(arguments));
   }
 
   @override
   ir.Expression visitThisPropertySet(SendSet node, Name name, Node rhs, _) {
     return buildThisPropertyAccessor(name)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
-  ir.Throw visitTopLevelConstantDeclaration(
+  ir.Expression visitTopLevelConstantDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       ConstantExpression constant,
       _) {
-    return buildUnsupported(node, "TopLevelConstantDeclaration");
+    // Shouldn't be called, handled by fieldToIr.
+    return internalError(node, "TopLevelFieldDeclaration");
   }
 
   @override
-  ir.Throw visitTopLevelFieldDeclaration(
+  ir.Expression visitTopLevelFieldDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       Node initializer,
       _) {
-    return buildUnsupported(node, "TopLevelFieldDeclaration");
+    // Shouldn't be called, handled by fieldToIr.
+    return internalError(node, "TopLevelFieldDeclaration");
   }
 
   @override
   IrFunction visitTopLevelFunctionDeclaration(
       FunctionExpression node,
       MethodElement function,
       NodeList parameters,
       Node body,
       _) {
     return buildIrFunction(ir.ProcedureKind.Method, function, body);
@@ skipping 114 matching lines @@
       Send node,
       UnaryOperator operator,
       Node expression, _) {
     return new ir.MethodInvocation(
         visitForValue(expression),
         kernel.irName(operator.selectorName, currentElement),
         new ir.Arguments.empty());
   }
 
   @override
-  ir.Throw visitConditionalUri(ConditionalUri node) {
-    return buildUnsupported(node, "ConditionalUri");
+  visitConditionalUri(ConditionalUri node) {
+    // Shouldn't be called, handled by library loader.
+    return internalError(node, "ConditionalUri");
   }
 
   @override
-  ir.Throw visitDottedName(DottedName node) {
-    return buildUnsupported(node, "DottedName");
+  visitDottedName(DottedName node) {
+    // Shouldn't be called, handled by library loader.
+    return internalError(node, "DottedName");
   }
 
   @override
-  ir.Throw visitForIn(ForIn node) {
-    return internalError(
-        node, "Should have been caught by visitAsyncForIn or visitSyncForIn");
+  visitForIn(ForIn node) {
+    // Shouldn't be called, handled by [visitAsyncForIn] or [visitSyncForIn].
+    return internalError(node, "ForIn");
   }
 
   @override
   ir.Expression visitIndexSetIfNull(
       SendSet node, Node receiver, Node index, Node rhs, _) {
     return buildIndexAccessor(receiver, index)
         .buildNullAwareAssignment(
             visitForValue(rhs), voidContext: isVoidContext);
   }
 
@@ skipping 108 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }