Remove unused API.

dart/sdk/lib/_internal/compiler/implementation/resolution/members.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 resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 510 matching lines @@
     });
   }
 
   /// This method should only be used by this library (or tests of
   /// this library).
   ResolverVisitor visitorFor(Element element) {
     var mapping = new TreeElementMapping(element);
     return new ResolverVisitor(compiler, element, mapping);
   }
 
-  void visitBody(ResolverVisitor visitor, Statement body) {
-    if (!compiler.analyzeSignaturesOnly) {
-      visitor.visit(body);
-    }
-  }
-
   TreeElements resolveField(VariableElement element) {
     Node tree = element.parseNode(compiler);
     if(element.modifiers.isStatic() && element.variables.isTopLevel()) {
       error(element.modifiers.getStatic(),
             MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
     visitor.useElement(tree, element);
 
     SendSet send = tree.asSendSet();
@@ skipping 870 matching lines @@
                            : MessageKind.NO_MATCHING_CONSTRUCTOR;
         visitor.compiler.reportError(diagnosticNode, kind);
       } else if (caller.modifiers.isConst()
                  && !lookedupConstructor.modifiers.isConst()) {
         visitor.compiler.reportError(
             diagnosticNode, MessageKind.CONST_CALLS_NON_CONST);
       }
     }
   }
 
-  FunctionElement resolveRedirection(FunctionElement constructor,
-                                     FunctionExpression functionNode) {
-    if (functionNode.initializers == null) return null;
-    Link<Node> link = functionNode.initializers.nodes;
-    if (!link.isEmpty && Initializers.isConstructorRedirect(link.head)) {
-      return resolveSuperOrThisForSend(constructor, functionNode, link.head);
-    }
-    return null;
-  }
-
   /**
    * Resolve all initializers of this constructor. In the case of a redirecting
    * constructor, the resolved constructor's function element is returned.
    */
   FunctionElement resolveInitializers(FunctionElement constructor,
                                       FunctionExpression functionNode) {
     // Keep track of all "this.param" parameters specified for constructor so
     // that we can ensure that fields are initialized only once.
     FunctionSignature functionParameters =
         constructor.computeSignature(visitor.compiler);
@@ skipping 74 matching lines @@
 
   R visitEmptyStatement(Node node) => null;
 
   /** Convenience method for visiting nodes that may be null. */
   R visit(Node node) => (node == null) ? null : node.accept(this);
 
   void error(Node node, MessageKind kind, [Map arguments = const {}]) {
     compiler.reportFatalError(node, kind, arguments);
   }
 
-  void dualError(Node node, DualKind kind, [Map arguments = const {}]) {
-    error(node, kind.error, arguments);
-  }
-
   void warning(Node node, MessageKind kind, [Map arguments = const {}]) {
     ResolutionWarning message =
         new ResolutionWarning(kind, arguments, compiler.terseDiagnostics);
     compiler.reportWarning(node, message);
   }
 
-  void dualWarning(Node node, DualKind kind, [Map arguments = const {}]) {
-    warning(node, kind.warning, arguments);
-  }
-
   void cancel(Node node, String message) {
     compiler.cancel(message, node: node);
   }
 
   void internalError(Node node, String message) {
     compiler.internalError(message, node: node);
   }
 
   void unimplemented(Node node, String message) {
     compiler.unimplemented(message, node: node);
@@ skipping 772 matching lines @@
     world.registerInstantiatedClass(compiler.functionClass, mapping);
   }
 
   visitIf(If node) {
     doInPromotionScope(node.condition.expression, () => visit(node.condition));
     doInPromotionScope(node.thenPart,
         () => visitIn(node.thenPart, new BlockScope(scope)));
     visitIn(node.elsePart, new BlockScope(scope));
   }
 
-  static bool isLogicalOperator(Identifier op) {
-    String str = op.source;
-    return (identical(str, '&&') || str == '||' || str == '!');
-  }
-
   Element resolveSend(Send node) {
     Selector selector = resolveSelector(node, null);
     if (node.isSuperCall) mapping.superUses.add(node);
 
     if (node.receiver == null) {
       // If this send is of the form "assert(expr);", then
       // this is an assertion.
       if (selector.isAssert()) {
         if (selector.argumentCount != 1) {
           error(node.selector,
@@ skipping 2396 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }