Revert "Prepare for computation of NewStructure in Resolution."

pkg/compiler/lib/src/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.
 
 library dart2js.resolution.members;
 
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' show
     Compiler;
@@ skipping 31 matching lines @@
     CallStructure,
     Selector,
     UniverseSelector;
 
 import 'access_semantics.dart';
 import 'class_members.dart' show MembersCreator;
 import 'operators.dart';
 import 'send_structure.dart';
 
 import 'constructors.dart' show
-    ConstructorResolver,
-    ConstructorResult;
+    ConstructorResolver;
 import 'label_scope.dart' show
     StatementScope;
 import 'registry.dart' show
     ResolutionRegistry;
 import 'resolution.dart' show
     ResolverTask;
 import 'resolution_common.dart' show
     MappingVisitor;
 import 'resolution_result.dart';
 import 'scope.dart' show
@@ skipping 3566 matching lines @@
     if (!enclosingElement.isFactoryConstructor) {
       compiler.reportError(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
       compiler.reportHint(
           enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
     }
     ConstructorElementX constructor = enclosingElement;
     bool isConstConstructor = constructor.isConst;
     bool isValidAsConstant = isConstConstructor;
     ConstructorElement redirectionTarget = resolveRedirectingFactory(
-        node, inConstContext: isConstConstructor).element;
+        node, inConstContext: isConstConstructor);
     constructor.immediateRedirectionTarget = redirectionTarget;
 
     Node constructorReference = node.constructorReference;
     if (constructorReference is Send) {
       constructor.redirectionDeferredPrefix =
           compiler.deferredLoadTask.deferredPrefixElement(constructorReference,
                                                           registry.mapping);
     }
 
     registry.setRedirectingTargetConstructor(node, redirectionTarget);
@@ skipping 157 matching lines @@
     allowedCategory = oldCategory;
     sendIsMemberAccess = oldSendIsMemberAccess;
     if (result.kind == ResultKind.CONSTANT) {
       return result;
     }
     return const NoneResult();
   }
 
   ResolutionResult visitNewExpression(NewExpression node) {
     bool isValidAsConstant = true;
-    ConstructorElement constructor = resolveConstructor(node).element;
+    FunctionElement constructor = resolveConstructor(node);
     final bool isSymbolConstructor = constructor == compiler.symbolConstructor;
     final bool isMirrorsUsedConstant =
         node.isConst && (constructor == compiler.mirrorsUsedConstructor);
     Selector callSelector = resolveSelector(node.send, constructor);
     ArgumentsResult argumentsResult;
     if (node.isConst) {
       argumentsResult =
           inConstantContext(() => resolveArguments(node.send.argumentsNode));
     } else {
       argumentsResult = resolveArguments(node.send.argumentsNode);
@@ skipping 21 matching lines @@
     InterfaceType type = registry.getType(node);
     if (node.isConst && type.containsTypeVariables) {
       compiler.reportError(node.send.selector,
                            MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       isValidAsConstant = false;
     }
     // TODO(johniwinther): Avoid registration of `type` in face of redirecting
     // factory constructors.
     registry.registerInstantiatedType(type);
     if (constructor.isGenerativeConstructor && cls.isAbstract) {
+      warning(node, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
+      registry.registerAbstractClassInstantiation();
       isValidAsConstant = false;
     }
 
     if (isSymbolConstructor) {
       if (node.isConst) {
         Node argumentNode = node.send.arguments.head;
         ConstantExpression constant =
             compiler.resolver.constantCompiler.compileNode(
                 argumentNode, registry.mapping);
         ConstantValue name = compiler.constants.getConstantValue(constant);
@@ skipping 115 matching lines @@
       return false;
     }
     return true;
   }
 
   /**
    * Try to resolve the constructor that is referred to by [node].
    * Note: this function may return an ErroneousFunctionElement instead of
    * [:null:], if there is no corresponding constructor, class or library.
    */
-  ConstructorResult resolveConstructor(NewExpression node) {
-    return node.accept(new ConstructorResolver(
-        compiler, this, inConstContext: node.isConst));
+  ConstructorElement resolveConstructor(NewExpression node) {
+    return node.accept(new ConstructorResolver(compiler, this));
   }
 
-  ConstructorResult resolveRedirectingFactory(RedirectingFactoryBody node,
+  ConstructorElement resolveRedirectingFactory(RedirectingFactoryBody node,
                                                {bool inConstContext: false}) {
-    return node.accept(new ConstructorResolver(
-        compiler, this, inConstContext: inConstContext));
+    return node.accept(new ConstructorResolver(compiler, this,
+                                               inConstContext: inConstContext));
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node,
                                  {bool malformedIsError: false,
                                   bool deferredIsMalformed: true}) {
     DartType type = typeResolver.resolveTypeAnnotation(
         this, node, malformedIsError: malformedIsError,
         deferredIsMalformed: deferredIsMalformed);
     if (inCheckContext) {
       registry.registerIsCheck(type);
@@ skipping 630 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// 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);
 }