Introduce unreachable helper.

lib/compiler/implementation/dart_backend/placeholder_collector.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 LocalPlaceholder implements Hashable {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
   int hashCode() => identifier.hashCode();
   String toString() =>
@@ skipping 125 matching lines @@
             if (send !== null) {
               assert(send.receiver is Identifier);
               assert(send.receiver.asIdentifier().isThis());
               if (send.selector is Identifier) {
                 tryMakePrivateIdentifier(send.selector.asIdentifier());
               } else if (send.selector is FunctionExpression) {
                 // C(int this.f()) case where f is field of function type.
                 tryMakePrivateIdentifier(
                     send.selector.asFunctionExpression().name.asIdentifier());
               } else {
-                internalError('Unreachable case');
+                unreachable();
               }
             } else {
               assert(definition is Identifier
                   || definition is FunctionExpression);
             }
           }
         } else {
           assert(parameter is NodeList);
           // We don't have to rename privates in optionals.
         }
@@ skipping 16 matching lines @@
   void collectFieldDeclarationPlaceholders(
       Element element, VariableDefinitions node) {
     if (element.isInstanceMember()) {
       for (Node definition in node.definitions) {
         if (definition is Identifier) {
           tryMakePrivateIdentifier(definition.asIdentifier());
         } else if (definition is SendSet) {
           tryMakePrivateIdentifier(
               definition.asSendSet().selector.asIdentifier());
         } else {
-          internalError('Unreachable case');
+          unreachable();
         }
       }
     } else if (element.isTopLevel()) {
       Node fieldNode = element.parseNode(compiler);
       if (fieldNode is Identifier) {
         makeElementPlaceholder(fieldNode, element);
       } else if (fieldNode is SendSet) {
         makeElementPlaceholder(fieldNode.selector, element);
       } else {
-        internalError('Unreachable case');
+        unreachable();
       }
     }
   }
 
   void collect(Element element, TreeElements elements) {
     treeElements = elements;
     Node elementNode;
     if (element is FunctionElement) {
       currentElement = element;
       elementNode = currentElement.parseNode(compiler);
       collectFunctionDeclarationPlaceholders(element, elementNode);
     } else if (element.isField()) {
       // TODO(smok): In the future make sure we don't process same
       // variable list element twice, better merge this with emitter logic.
       currentElement = (element as VariableElement).variables;
       elementNode = currentElement.parseNode(compiler);
       // We don't collect other elements from the same variable lists
       // if they are not used. http://dartbug.com/4536
       collectFieldDeclarationPlaceholders(element, elementNode);
     } else if (element is ClassElement || element is TypedefElement) {
       currentElement = element;
       elementNode = currentElement.parseNode(compiler);
     } else {
-      assert(false); // Unreachable.
+      unreachable();
     }
     currentLocalPlaceholders = new Map<String, LocalPlaceholder>();
     compiler.withCurrentElement(element, () {
       elementNode.accept(this);
     });
   }
 
   void tryMakePrivateIdentifier(Identifier identifier) {
     if (identifier.source.isPrivate()) makePrivateIdentifier(identifier);
   }
@@ skipping 44 matching lines @@
               localPlaceholders.putIfAbsent(currentElement,
                   () => new Set<LocalPlaceholder>()).add(localPlaceholder);
               return localPlaceholder;
             });
   }
 
   void internalError(String reason, [Node node]) {
     compiler.cancel(reason: reason, node: node);
   }
 
+  void unreachable() { internalError('Unreachable case'); }
+
   visit(Node node) => (node === null) ? null : node.accept(this);
 
   visitNode(Node node) { node.visitChildren(this); }  // We must go deeper.
 
   visitSend(Send send) {
     new SendVisitor(this, treeElements).visitSend(send);
     send.visitChildren(this);
   }
 
   visitSendSet(SendSet send) {
@@ skipping 121 matching lines @@
       visit(node.defaultClause.typeArguments);
     }
   }
 
   visitTypedef(Typedef node) {
     assert(currentElement is TypedefElement);
     makeElementPlaceholder(node.name, currentElement);
     node.visitChildren(this);
   }
 }