Inheritance manager fix for fuzzy arrows

pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 799 matching lines @@
             } else {
               //
               // Example: class A inherits 2 methods named 'm'.
               // One has the function type '(int) -> dynamic' and one has the
               // function type '(num) -> dynamic'. Since they are both a subtype
               // of the other, a synthetic function '(dynamic) -> dynamic' is
               // inherited.
               // Tests: test_getMapOfMembersInheritedFromInterfaces_
               // union_multipleSubtypes_*
               //
+              // TODO(leafp): this produces (dynamic) -> dynamic even if
+              // the types are equal which gives bad error messages. If
+              // types are equal, we should consider using them.  Even
+              // better, consider using the GLB of the parameter types
+              // and the LUB of the return types
               List<ExecutableElement> elementArrayToMerge =
                   new List<ExecutableElement>(
                       subtypesOfAllOtherTypesIndexes.length);
               for (int i = 0; i < elementArrayToMerge.length; i++) {
                 elementArrayToMerge[i] =
                     elements[subtypesOfAllOtherTypesIndexes[i]];
               }
               ExecutableElement mergedExecutableElement =
                   _computeMergedExecutableElement(elementArrayToMerge);
               resultMap[key] = mergedExecutableElement;
@@ skipping 83 matching lines @@
    * function <i>f</i>, and let <i>numberOfRequiredParams</i>(<i>f</i>) denote the number of
    * required parameters of a function <i>f</i>. Furthermore, let <i>s</i> denote the set of all
    * named parameters of the <i>m<sub>1</sub>, &hellip;, m<sub>k</sub></i>. Then let
    * * <i>h = max(numberOfPositionals(m<sub>i</sub>)),</i>
    * * <i>r = min(numberOfRequiredParams(m<sub>i</sub>)), for all <i>i</i>, 1 <= i <= k.</i>
    * Then <i>I</i> has a method named <i>n</i>, with <i>r</i> required parameters of type
    * <b>dynamic</b>, <i>h</i> positional parameters of type <b>dynamic</b>, named parameters
    * <i>s</i> of type <b>dynamic</b> and return type <b>dynamic</b>.
    *
    */
-  static ExecutableElement _computeMergedExecutableElement(
+  ExecutableElement _computeMergedExecutableElement(
       List<ExecutableElement> elementArrayToMerge) {
     int h = _getNumOfPositionalParameters(elementArrayToMerge[0]);
     int r = _getNumOfRequiredParameters(elementArrayToMerge[0]);
     Set<String> namedParametersList = new HashSet<String>();
     for (int i = 1; i < elementArrayToMerge.length; i++) {
       ExecutableElement element = elementArrayToMerge[i];
       int numOfPositionalParams = _getNumOfPositionalParameters(element);
       if (h < numOfPositionalParams) {
         h = numOfPositionalParams;
       }
@@ skipping 15 matching lines @@
    * Used by [computeMergedExecutableElement] to actually create the
    * synthetic element.
    *
    * @param elementArrayToMerge the array used to create the synthetic element
    * @param name the name of the method, getter or setter
    * @param numOfRequiredParameters the number of required parameters
    * @param numOfPositionalParameters the number of positional parameters
    * @param namedParameters the list of [String]s that are the named parameters
    * @return the created synthetic element
    */
-  static ExecutableElement _createSyntheticExecutableElement(
+  ExecutableElement _createSyntheticExecutableElement(
       List<ExecutableElement> elementArrayToMerge,
       String name,
       int numOfRequiredParameters,
       int numOfPositionalParameters,
       List<String> namedParameters) {
     DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
+    DartType bottomType = _library.context.analysisOptions.strongMode
+        ? BottomTypeImpl.instance
+        : dynamicType;
     SimpleIdentifier nameIdentifier = astFactory
         .simpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, 0));
     ExecutableElementImpl executable;
     ExecutableElement elementToMerge = elementArrayToMerge[0];
     if (elementToMerge is MethodElement) {
       MultiplyInheritedMethodElementImpl unionedMethod =
           new MultiplyInheritedMethodElementImpl(nameIdentifier);
       unionedMethod.inheritedElements = elementArrayToMerge;
       executable = unionedMethod;
     } else if (elementToMerge is PropertyAccessorElement) {
       MultiplyInheritedPropertyAccessorElementImpl unionedPropertyAccessor =
           new MultiplyInheritedPropertyAccessorElementImpl(nameIdentifier);
       unionedPropertyAccessor.getter = elementToMerge.isGetter;
       unionedPropertyAccessor.setter = elementToMerge.isSetter;
       unionedPropertyAccessor.inheritedElements = elementArrayToMerge;
       executable = unionedPropertyAccessor;
     } else {
       throw new AnalysisException(
           'Invalid class of element in merge: ${elementToMerge.runtimeType}');
     }
     int numOfParameters = numOfRequiredParameters +
         numOfPositionalParameters +
         namedParameters.length;
     List<ParameterElement> parameters =
         new List<ParameterElement>(numOfParameters);
     int i = 0;
     for (int j = 0; j < numOfRequiredParameters; j++, i++) {
       ParameterElementImpl parameter = new ParameterElementImpl("", 0);
-      parameter.type = dynamicType;
+      parameter.type = bottomType;
       parameter.parameterKind = ParameterKind.REQUIRED;
       parameters[i] = parameter;
     }
     for (int k = 0; k < numOfPositionalParameters; k++, i++) {
       ParameterElementImpl parameter = new ParameterElementImpl("", 0);
-      parameter.type = dynamicType;
+      parameter.type = bottomType;
       parameter.parameterKind = ParameterKind.POSITIONAL;
       parameters[i] = parameter;
     }
     for (int m = 0; m < namedParameters.length; m++, i++) {
       ParameterElementImpl parameter =
           new ParameterElementImpl(namedParameters[m], 0);
-      parameter.type = dynamicType;
+      parameter.type = bottomType;
       parameter.parameterKind = ParameterKind.NAMED;
       parameters[i] = parameter;
     }
     executable.returnType = dynamicType;
     executable.parameters = parameters;
     FunctionTypeImpl methodType = new FunctionTypeImpl(executable);
     executable.type = methodType;
     return executable;
   }
 
@@ skipping 230 matching lines @@
   }
 
   /**
    * Initializes [keys] and [values].
    */
   void _initArrays(int initialCapacity) {
     _keys = new List<String>(initialCapacity);
     _values = new List<ExecutableElement>(initialCapacity);
   }
 }