Remove union type support from analyzer.

pkg/analyzer/lib/src/generated/element_resolver.dart

 // Copyright (c) 2014, 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 engine.resolver.element_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 621 matching lines @@
       }
     }
     //
     // Then check for error conditions.
     //
     ErrorCode errorCode = _checkForInvocationError(target, true, staticElement);
     bool generatedWithTypePropagation = false;
     if (_enableHints && errorCode == null && staticElement == null) {
       // The method lookup may have failed because there were multiple
       // incompatible choices. In this case we don't want to generate a hint.
-      if (propagatedElement == null && propagatedType is UnionType) {
-        // TODO(collinsn): an improvement here is to make the propagated type
-        // of the method call the union of the propagated types of all possible
-        // calls.
-        if (_lookupMethods(target, propagatedType, methodName.name).length >
-            1) {
-          return null;
-        }
-      }
       errorCode = _checkForInvocationError(target, false, propagatedElement);
       if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
         ClassElement classElementContext = null;
         if (target == null) {
           classElementContext = _resolver.enclosingClass;
         } else {
           DartType type = target.bestType;
           if (type != null) {
             if (type.element is ClassElement) {
               classElementContext = type.element as ClassElement;
@@ skipping 1055 matching lines @@
         method = interfaceType.lookUpMethodInSuperclass(
             methodName, _definingLibrary);
       } else {
         method = interfaceType.lookUpMethod(methodName, _definingLibrary);
       }
       if (method != null) {
         return method;
       }
       return _lookUpMethodInInterfaces(
           interfaceType, false, methodName, new HashSet<ClassElement>());
-    } else if (type is UnionType) {
-      // TODO (collinsn): I want [computeMergedExecutableElement] to be general
-      // and work with functions, methods, constructors, and property accessors.
-      // However, I won't be able to assume it returns [MethodElement] here
-      // then.
-      return _maybeMergeExecutableElements(
-          _lookupMethods(target, type, methodName)) as MethodElement;
     }
     return null;
   }
 
   /**
    * Look up the method with the given [methodName] in the interfaces
    * implemented by the given [targetType], either directly or indirectly.
    * Return the element representing the method that was found, or `null` if
    * there is no method with the given name. The flag [includeTargetType] should
    * be `true` if the search should include the target type. The
@@ skipping 35 matching lines @@
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
     return _lookUpMethodInInterfaces(
         superclass, true, methodName, visitedInterfaces);
   }
 
   /**
-   * Look up all methods with the given [methodName] that are defined on the
-   * given union [type].
-   */
-  Set<ExecutableElement> _lookupMethods(
-      Expression target, UnionType type, String methodName) {
-    Set<ExecutableElement> methods = new HashSet<ExecutableElement>();
-    bool allElementsHaveMethod = true;
-    for (DartType t in type.elements) {
-      MethodElement m = _lookUpMethod(target, t, methodName);
-      if (m != null) {
-        methods.add(m);
-      } else {
-        allElementsHaveMethod = false;
-      }
-    }
-    // For strict union types we require that all types in the union define the
-    // method.
-    if (AnalysisEngine.instance.strictUnionTypes) {
-      if (allElementsHaveMethod) {
-        return methods;
-      } else {
-        return new Set<ExecutableElement>();
-      }
-    } else {
-      return methods;
-    }
-  }
-
-  /**
    * Look up the setter with the given [setterName] in the given [type]. Return
    * the element representing the setter that was found, or `null` if there is
    * no setter with the given name. The [target] is the target of the
    * invocation, or `null` if there is no target.
    */
   PropertyAccessorElement _lookUpSetter(
       Expression target, DartType type, String setterName) {
     type = _resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
@@ skipping 555 matching lines @@
    * Given an invocation of the form 'e.m(a1, ..., an)', resolve 'e.m' to the
    * element being invoked. If the returned element is a method, then the method
    * will be invoked. If the returned element is a getter, the getter will be
    * invoked without arguments and the result of that invocation will then be
    * invoked with the arguments. The [target] is the target of the invocation
    * ('e'). The [targetType] is the type of the target. The [methodName] is th
    *  name of the method being invoked ('m').
    */
   Element _resolveInvokedElementWithTarget(
       Expression target, DartType targetType, SimpleIdentifier methodName) {
-    if (targetType is InterfaceType || targetType is UnionType) {
+    if (targetType is InterfaceType) {
       Element element = _lookUpMethod(target, targetType, methodName.name);
       if (element == null) {
         //
         // If there's no method, then it's possible that 'm' is a getter that
         // returns a function.
         //
         // TODO (collinsn): need to add union type support here too, in the
         // style of [lookUpMethod].
         element = _lookUpGetter(target, targetType, methodName.name);
       }
@@ skipping 76 matching lines @@
     propertyName.staticElement = staticElement;
     propertyName.propagatedElement = propagatedElement;
     bool shouldReportMissingMember_static =
         _shouldReportMissingMember(staticType, staticElement);
     bool shouldReportMissingMember_propagated =
         !shouldReportMissingMember_static &&
             _enableHints &&
             _shouldReportMissingMember(propagatedType, propagatedElement) &&
             !_memberFoundInSubclass(
                 propagatedType.element, propertyName.name, false, true);
-    // TODO(collinsn): add support for errors on union types by extending
-    // [lookupGetter] and [lookupSetter] in analogy with the earlier
-    // [lookupMethod] extensions.
-    if (propagatedType is UnionType) {
-      shouldReportMissingMember_propagated = false;
-    }
     if (shouldReportMissingMember_static ||
         shouldReportMissingMember_propagated) {
       DartType staticOrPropagatedType =
           shouldReportMissingMember_static ? staticType : propagatedType;
       Element staticOrPropagatedEnclosingElt = staticOrPropagatedType.element;
       bool isStaticProperty = _isStatic(staticOrPropagatedEnclosingElt);
       DartType displayType = staticOrPropagatedType != null
           ? staticOrPropagatedType
           : propagatedType != null ? propagatedType : staticType;
       // Special getter cases.
@@ skipping 208 matching lines @@
     if (!isConditional && expression is Identifier) {
       Element staticElement = expression.staticElement;
       if (staticElement is ClassElementImpl) {
         return staticElement;
       }
     }
     return null;
   }
 
   /**
-   * Helper function for `maybeMergeExecutableElements` that does the actual
-   * merging. The [elementArrayToMerge] is the non-empty list of elements to
-   * merge.
-   */
-  static ExecutableElement _computeMergedExecutableElement(
-      List<ExecutableElement> elementArrayToMerge) {
-    // Flatten methods structurally. Based on
-    // [InheritanceManager.computeMergedExecutableElement] and
-    // [InheritanceManager.createSyntheticExecutableElement].
-    //
-    // However, the approach we take here is much simpler, but expected to work
-    // well in the common case. It degrades gracefully in the uncommon case,
-    // by computing the type [dynamic] for the method, preventing any
-    // hints from being generated (TODO: not done yet).
-    //
-    // The approach is: we require that each [ExecutableElement] has the
-    // same shape: the same number of required, optional positional, and
-    // optional named parameters, in the same positions, and with the named
-    // parameters in the same order. We compute a type by unioning pointwise.
-    ExecutableElement e_0 = elementArrayToMerge[0];
-    List<ParameterElement> ps_0 = e_0.parameters;
-    List<ParameterElementImpl> ps_out =
-        new List<ParameterElementImpl>(ps_0.length);
-    for (int j = 0; j < ps_out.length; j++) {
-      ps_out[j] = new ParameterElementImpl(ps_0[j].name, 0);
-      ps_out[j].synthetic = true;
-      ps_out[j].type = ps_0[j].type;
-      ps_out[j].parameterKind = ps_0[j].parameterKind;
-    }
-    DartType r_out = e_0.returnType;
-    for (int i = 1; i < elementArrayToMerge.length; i++) {
-      ExecutableElement e_i = elementArrayToMerge[i];
-      r_out = UnionTypeImpl.union([r_out, e_i.returnType]);
-      List<ParameterElement> ps_i = e_i.parameters;
-      // Each function must have the same number of params.
-      if (ps_0.length != ps_i.length) {
-        return null;
-        // TODO (collinsn): return an element representing [dynamic] here
-        // instead.
-      } else {
-        // Each function must have the same kind of params, with the same names,
-        // in the same order.
-        for (int j = 0; j < ps_i.length; j++) {
-          if (ps_0[j].parameterKind != ps_i[j].parameterKind ||
-              !identical(ps_0[j].name, ps_i[j].name)) {
-            return null;
-          } else {
-            // The output parameter type is the union of the input parameter
-            // types.
-            ps_out[j].type =
-                UnionTypeImpl.union([ps_out[j].type, ps_i[j].type]);
-          }
-        }
-      }
-    }
-    // TODO (collinsn): this code should work for functions and methods,
-    // so we may want [FunctionElementImpl]
-    // instead here in some cases?
-    // And then there are constructors and property accessors.
-    // Maybe the answer is to create a new subclass of [ExecutableElementImpl]
-    // which is used for merged executable elements, in analogy with
-    // [MultiplyInheritedMethodElementImpl] and
-    // [MultiplyInheritedPropertyAcessorElementImpl].
-    ExecutableElementImpl e_out = new MethodElementImpl(e_0.name, 0);
-    e_out.synthetic = true;
-    e_out.returnType = r_out;
-    e_out.parameters = ps_out;
-    e_out.type = new FunctionTypeImpl.con1(e_out);
-    // Get NPE in [toString()] w/o this.
-    e_out.enclosingElement = e_0.enclosingElement;
-    return e_out;
-  }
-
-  /**
    * Return `true` if the given [identifier] is the return type of a constructor
    * declaration.
    */
   static bool _isConstructorReturnType(SimpleIdentifier identifier) {
     AstNode parent = identifier.parent;
     if (parent is ConstructorDeclaration) {
       return identical(parent.returnType, identifier);
     }
     return false;
   }
@@ skipping 25 matching lines @@
       }
       if (node is ConstructorFieldInitializer) {
         return false;
       }
       if (node is MethodDeclaration) {
         return !node.isStatic;
       }
     }
     return false;
   }
-
-  /**
-   * Return a method representing the merge of the given [elements]. The type of
-   * the merged element is the component-wise union of the types of the given
-   * elements. If not all input elements have the same shape then `null` is
-   * returned.
-   */
-  static ExecutableElement _maybeMergeExecutableElements(
-      Set<ExecutableElement> elements) {
-    List<ExecutableElement> elementArrayToMerge = new List.from(elements);
-    if (elementArrayToMerge.length == 0) {
-      return null;
-    } else if (elementArrayToMerge.length == 1) {
-      // If all methods are equal, don't bother building a new one.
-      return elementArrayToMerge[0];
-    } else {
-      return _computeMergedExecutableElement(elementArrayToMerge);
-    }
-  }
 }
 
 /**
  * An identifier that can be used to look up names in the lexical scope when
  * there is no identifier in the AST structure. There is no identifier in the
  * AST when the parser could not distinguish between a method invocation and an
  * invocation of a top-level function imported with a prefix.
  */
 class SyntheticIdentifier extends Identifier {
   /**
@@ skipping 43 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }