Use templates for BulkMixin messages.

pkg/compiler/lib/src/resolution/semantic_visitor_mixins.dart

 // Copyright (c) 2015, 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 dart2js.semantics_visitor;
 
+/// Interface for bulk handling of a [Node] in a semantic visitor.
+abstract class BulkHandle<R, A> {
+  /// Handle [node] either regardless of semantics or to report that [node] is
+  /// unhandled. [message] contains a message template for the latter case:
+  /// Replace '#' in [message] by `node.toString()` to create a message for the
+  /// error.
+  R bulkHandleNode(Node node, String message, A arg);
+}
+
 /// Mixin that implements all `errorX` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `errorX` methods.
-abstract class ErrorBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class ErrorBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {

[floitsch, 2015/04/15 13:24:45]

I would "extends BulkHandle". (same for the others).

[Johnni Winther, 2015/04/15 14:35:40]

Doesn't work; it would not be allowed as a mixin :-(

 
   R bulkHandleError(Node node, A arg) {
-    return bulkHandleNode(node, "Error expression `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Error expression `#` unhandled.", arg);
   }
 
   @override
   R errorInvalidAssert(
       Send node,
       NodeList arguments,
       A arg) {
     return bulkHandleError(node, arg);
   }
 
@@ skipping 572 matching lines @@
       A arg) {
     return bulkHandleError(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXPrefix` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXPrefix`
 /// methods.
-abstract class PrefixBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class PrefixBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandlePrefix(Send node, A arg) {
-    return bulkHandleNode(node, "Prefix expression `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Prefix expression `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyPrefix(
       Send node,
       Node receiver,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
@@ skipping 165 matching lines @@
       A arg) {
     return bulkHandlePrefix(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXPostfix` methods of [SemanticSendVisitor]
 /// by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXPostfix`
 /// methods.
-abstract class PostfixBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class PostfixBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandlePostfix(Send node, A arg) {
-    return bulkHandleNode(node, "Postfix expression `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Postfix expression `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyPostfix(
       Send node,
       Node receiver,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
@@ skipping 165 matching lines @@
       A arg) {
     return bulkHandlePostfix(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor]
 /// by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `xCompound`
 /// methods.
-abstract class CompoundBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class CompoundBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleCompound(Send node, A arg) {
-    return bulkHandleNode(node, "Compound assignment `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Compound assignment `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyCompound(
       Send node,
       Node receiver,
       AssignmentOperator operator,
       Node rhs,
       Selector getterSelector,
       Selector setterSelector,
@@ skipping 149 matching lines @@
       A arg) {
     return bulkHandleCompound(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXInvoke`
 /// methods.
-abstract class InvokeBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class InvokeBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleInvoke(Send node, A arg) {
-    return bulkHandleNode(node, "Invocation `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Invocation `#` unhandled.", arg);
   }
 
   @override
   R visitClassTypeLiteralInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return bulkHandleInvoke(node, arg);
@@ skipping 196 matching lines @@
       A arg) {
     return bulkHandleInvoke(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXGet` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXGet`
 /// methods.
-abstract class GetBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class GetBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleGet(Node node, A arg) {
-    return bulkHandleNode(node, "Read `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Read `#` unhandled.", arg);
   }
 
   @override
   R visitClassTypeLiteralGet(
       Send node,
       ConstantExpression constant,
       A arg) {
     return bulkHandleGet(node, arg);
   }
 
@@ skipping 146 matching lines @@
       A arg) {
     return bulkHandleGet(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXSet` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXSet`
 /// methods.
-abstract class SetBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class SetBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleSet(Send node, A arg) {
-    return bulkHandleNode(node, "Assignment `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Assignment `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertySet(
       SendSet node,
       Node receiver,
       Selector selector,
       Node rhs,
       A arg) {
     return bulkHandleSet(node, arg);
@@ skipping 79 matching lines @@
       A arg) {
     return bulkHandleSet(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXIndexSet` methods of [SemanticSendVisitor]
 /// by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXIndexSet`
 /// methods.
-abstract class IndexSetBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class IndexSetBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleIndexSet(Send node, A arg) {
-    return bulkHandleNode(node, "Index set expression `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Index set expression `#` unhandled.", arg);
   }
 
   @override
   R visitCompoundIndexSet(
       SendSet node,
       Node receiver,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
@@ skipping 31 matching lines @@
       A arg) {
     return bulkHandleIndexSet(node, arg);
   }
 }
 
 /// Mixin that implements all binary visitor methods in [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all binary visitor
 /// methods.
-abstract class BinaryBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class BinaryBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleBinary(Send node, A arg) {
-    return bulkHandleNode(node, "Binary expression `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Binary expression `#` unhandled.", arg);
   }
 
   @override
   R visitBinary(
       Send node,
       Node left,
       BinaryOperator operator,
       Node right,
       A arg) {
     return bulkHandleBinary(node, arg);
@@ skipping 62 matching lines @@
       A arg) {
     return bulkHandleBinary(node, arg);
   }
 }
 
 /// Mixin that implements all unary visitor methods in [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all unary visitor
 /// methods.
-abstract class UnaryBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class UnaryBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleUnary(Send node, A arg) {
-    return bulkHandleNode(node, "Unary expression `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Unary expression `#` unhandled.", arg);
   }
 
   @override
   R visitNot(
       Send node,
       Node expression,
       A arg) {
     return bulkHandleUnary(node, arg);
   }
 
@@ skipping 11 matching lines @@
       A arg) {
     return bulkHandleUnary(node, arg);
   }
 }
 
 /// Mixin that implements all purely structural visitor methods in
 /// [SemanticSendVisitor] by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all purely structural
 /// visitor methods.
-abstract class BaseBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class BaseBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   @override
   R visitAs(
       Send node,
       Node expression,
       DartType type,
       A arg) {
-    return bulkHandleNode(node, 'As cast `$node` unhandled.', arg);
+    return bulkHandleNode(node, 'As cast `#` unhandled.', arg);
   }
 
   @override
   R visitAssert(
       Send node,
       Node expression,
       A arg) {
-    return bulkHandleNode(node, 'Assert `$node` unhandled.', arg);
+    return bulkHandleNode(node, 'Assert `#` unhandled.', arg);
   }
 
   @override
   R visitIs(
       Send node,
       Node expression,
       DartType type,
       A arg) {
-    return bulkHandleNode(node, 'Is test `$node` unhandled.', arg);
+    return bulkHandleNode(node, 'Is test `#` unhandled.', arg);
   }
 
   @override
   R visitIsNot(
       Send node,
       Node expression,
       DartType type,
       A arg) {
-    return bulkHandleNode(node, 'Is not test `$node` unhandled.', arg);
+    return bulkHandleNode(node, 'Is not test `#` unhandled.', arg);
   }
 
   @override
   R visitLogicalAnd(
       Send node,
       Node left,
       Node right,
       A arg) {
-    return bulkHandleNode(node, 'Lazy and `$node` unhandled.', arg);
+    return bulkHandleNode(node, 'Lazy and `#` unhandled.', arg);
   }
 
   @override
   R visitLogicalOr(
       Send node,
       Node left,
       Node right,
       A arg) {
-    return bulkHandleNode(node, 'Lazy or `$node` unhandled.', arg);
+    return bulkHandleNode(node, 'Lazy or `#` unhandled.', arg);
   }
 }
 
 /// Mixin that implements all visitor methods for `super` calls in
 /// [SemanticSendVisitor] by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for `super` calls
 /// visitor methods.
-abstract class SuperBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class SuperBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleSuper(Send node, A arg) {
-    return bulkHandleNode(node, "Super call `$node` unhandled.", arg);
+    return bulkHandleNode(node, "Super call `#` unhandled.", arg);
   }
 
   @override
   R visitSuperBinary(
       Send node,
       FunctionElement function,
       BinaryOperator operator,
       Node argument,
       A arg) {
     return bulkHandleSuper(node, arg);
@@ skipping 286 matching lines @@
   @override
   R visitSuperUnary(
       Send node,
       UnaryOperator operator,
       FunctionElement function,
       A arg) {
     return bulkHandleSuper(node, arg);
   }
 }
 
-abstract class NewBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+abstract class NewBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleNew(NewExpression node, A arg) {
     return bulkHandleNode(
-        node, "Constructor invocation `$node` unhandled.", arg);
+        node, "Constructor invocation `#` unhandled.", arg);
   }
 
   @override
   R visitConstConstructorInvoke(
       NewExpression node,
       ConstructedConstantExpression constant,
       A arg) {
     return bulkHandleNew(node, arg);
   }
 
@@ skipping 69 matching lines @@
         "BulkSendVisitor.bulkHandleNode unimplemented");
   }
 }
 
 /// Mixin that implements all `visitXParameterDecl` and
 /// `visitXInitializingFormalDecl` methods of [SemanticDeclarationVisitor]
 /// by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for these methods.
 abstract class ParameterBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleParameterDeclaration(VariableDefinitions node, A arg) {
     return bulkHandleNode(
-        node, "Parameter declaration `$node` unhandled.", arg);
+        node, "Parameter declaration `#` unhandled.", arg);
   }
 
   @override
   R visitInitializingFormalDeclaration(
       VariableDefinitions node,
       Node definition,
       InitializingFormalElement parameter,
       int index,
       A arg) {
     return bulkHandleParameterDeclaration(node, arg);
@@ skipping 50 matching lines @@
       A arg) {
     return bulkHandleParameterDeclaration(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXConstructorDecl` methods of
 /// [SemanticDeclarationVisitor] by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for these methods.
 abstract class ConstructorBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleConstructorDeclaration(FunctionExpression node, A arg) {
     return bulkHandleNode(
-        node, "Constructor declaration `$node` unhandled.", arg);
+        node, "Constructor declaration `#` unhandled.", arg);
   }
 
   @override
   R visitFactoryConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
       Node body,
       A arg) {
     return bulkHandleConstructorDeclaration(node, arg);
@@ skipping 30 matching lines @@
       A arg) {
     return bulkHandleConstructorDeclaration(node, arg);
   }
 }
 
 /// Mixin that implements all constructor initializer visitor methods of
 /// [SemanticDeclarationVisitor] by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for these methods.
 abstract class InitializerBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleInitializer(Send node, A arg) {
     return bulkHandleNode(
-        node, "Initializer `$node` unhandled.", arg);
+        node, "Initializer `#` unhandled.", arg);
   }
 
   @override
   R errorUnresolvedFieldInitializer(
       SendSet node,
       Element element,
       Node initializer,
       A arg) {
     return bulkHandleInitializer(node, arg);
   }
@@ skipping 47 matching lines @@
       A arg) {
     return bulkHandleInitializer(node, arg);
   }
 }
 
 /// Mixin that implements all function declaration visitor methods of
 /// [SemanticDeclarationVisitor] by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for these methods.
 abstract class FunctionBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleFunctionDeclaration(FunctionExpression node, A arg) {
     return bulkHandleNode(
-        node, "Function declaration `$node` unhandled.", arg);
+        node, "Function declaration `#` unhandled.", arg);
   }
 
   @override
   R visitAbstractGetterDeclaration(
       FunctionExpression node,
       MethodElement getter,
       A arg) {
     return bulkHandleFunctionDeclaration(node, arg);
   }
 
@@ skipping 121 matching lines @@
       A arg) {
     return bulkHandleFunctionDeclaration(node, arg);
   }
 }
 
 /// Mixin that implements all variable/field declaration visitor methods of
 /// [SemanticDeclarationVisitor] by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for these methods.
 abstract class VariableBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A> {
-  R bulkHandleNode(Node node, String message, A arg);
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleVariableDeclaration(VariableDefinitions node, A arg) {
     return bulkHandleNode(
-        node, "Variable declaration `$node` unhandled.", arg);
+        node, "Variable declaration `#` unhandled.", arg);
   }
 
   @override
   R visitInstanceFieldDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       Node initializer,
       A arg) {
     return bulkHandleVariableDeclaration(node, arg);
@@ skipping 3715 matching lines @@
       InterfaceType type,
       ConstructorElement effectiveTarget,
       InterfaceType effectiveTargetType,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
 }