Deprecate visitAssertSend and visitTypePrefixSend

pkg/compiler/lib/src/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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 4556 matching lines @@
       DartType instance = type.asInstanceOf(supertype.element);
       compiler.types.checkTypeVariableBounds(instance,
           addTypeVariableBoundCheck);
       if (definitelyFails) {
         return true;
       }
     }
     return false;
   }
 
-  visitAssertSend(node) {
+  @override
+  visitAssert(ast.Send node, ast.Node expression, _) {
     if (!compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull(compiler));
       return;
     }
-    // TODO(johnniwinther): Don't handle assert like a regular static call.
-    // It breaks the selector name check since the assert helper method cannot
-    // be called `assert` and therefore does not match the selector like a
-    // regular method.
-    visitStaticSend(node);
+    assert(invariant(node, node.arguments.tail.isEmpty,
+        message: "Invalid assertion: $node"));
+    buildStaticFunctionInvoke(
+        node, backend.assertMethod, CallStructure.ONE_ARG);
   }
 
   visitStaticSend(ast.Send node) {
     CallStructure callStructure = elements.getSelector(node).callStructure;
     Element element = elements[node];
     if (elements.isAssert(node)) {
       element = backend.assertMethod;
     }
     if (element.isForeign(backend) && element.isFunction) {
       visitForeignSend(node);
@@ skipping 14 matching lines @@
     }
     invariant(element, !element.isGenerativeConstructor);
     generateIsDeferredLoadedCheckIfNeeded(node);
     if (element.isFunction) {
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [makeStaticArgumentList].
       if (!callStructure.signatureApplies(element.implementation)) {
         generateWrongArgumentCountError(node, element, node.arguments);
         return;
       }
-
-      List<HInstruction> inputs =
-          makeStaticArgumentList(callStructure,
-                                 node.arguments,
-                                 element.implementation);
-
-      if (element == compiler.identicalFunction) {
-        pushWithPosition(
-            new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
-        return;
-      }
-
-      pushInvokeStatic(node, element, inputs);
+      buildStaticFunctionInvoke(node, element, callStructure);
     } else {
       generateGetter(node, element);
       List<HInstruction> inputs = <HInstruction>[pop()];
       addDynamicSendArgumentsToList(node, inputs);
       Selector closureSelector = callStructure.callSelector;
       pushWithPosition(
           new HInvokeClosure(closureSelector, inputs, backend.dynamicType),
           node);
     }
   }
 
+  void buildStaticFunctionInvoke(
+      ast.Send node,
+      FunctionElement element,
+      CallStructure callStructure) {
+    List<HInstruction> inputs = makeStaticArgumentList(
+        callStructure,
+        node.arguments,
+        element.implementation);
+
+    if (element == compiler.identicalFunction) {
+      pushWithPosition(
+          new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
+      return;
+    } else {
+      pushInvokeStatic(node, element, inputs);
+    }
+  }
+
   HConstant addConstantString(String string) {
     ast.DartString dartString = new ast.DartString.literal(string);
     ConstantValue constant = constantSystem.createString(dartString);
     return graph.addConstant(constant, compiler);
   }
 
-  visitTypePrefixSend(ast.Send node) {
-    compiler.internalError(node, "visitTypePrefixSend should not be called.");
-  }
-
   visitTypeLiteralSend(ast.Send node) {
     DartType type = elements.getTypeLiteralType(node);
     if (type.isInterfaceType || type.isTypedef || type.isDynamic) {
       // TODO(karlklose): add type representation
       if (node.isCall) {
         // The node itself is not a constant but we register the selector (the
         // identifier that refers to the class/typedef) as a constant.
         stack.add(addConstant(node.selector));
       } else {
         stack.add(addConstant(node));
@@ skipping 2336 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }