dart-lang
diff --git a/‎pkg/analyzer/lib/src/dart/element/type.dart‎
Lines changed: 5 additions & 1 deletion b/‎pkg/analyzer/lib/src/dart/element/type.dart‎
Lines changed: 5 additions & 1 deletion
diff --git a/‎pkg/analyzer/lib/src/generated/type_system.dart‎
Lines changed: 32 additions & 3 deletions b/‎pkg/analyzer/lib/src/generated/type_system.dart‎
Lines changed: 32 additions & 3 deletions
@@ -1212,14 +1212,18 @@ abstract class FunctionTypeImpl extends TypeImpl implements FunctionType {
       variables1.add(variable1);
       variables2.add(variable2);
       variablesFresh.add(variableFresh);
+
       DartType bound1 = p1.bound ?? DynamicTypeImpl.instance;
       DartType bound2 = p2.bound ?? DynamicTypeImpl.instance;
       bound1 = bound1.substitute2(variablesFresh, variables1);
       bound2 = bound2.substitute2(variablesFresh, variables2);
-      pFresh.bound = bound2;
       if (!relation(bound2, bound1, p2, p1)) {
         return null;
       }
+
+      if (!bound2.isDynamic) {
+        pFresh.bound = bound2;
+      }
     }
     return variablesFresh;
   }
 
@@ -2342,8 +2342,30 @@ abstract class TypeSystem implements public.TypeSystem {
    *   Return a function type with those types.
    */
   DartType _functionLeastUpperBound(FunctionType f, FunctionType g) {
-    // TODO(rnystrom): Right now, this assumes f and g do not have any type
-    // parameters. Revisit that in the presence of generic methods.
+    var fTypeFormals = f.typeFormals;
+    var gTypeFormals = g.typeFormals;
+
+    // If F and G differ in their number of type parameters, then the
+    // least upper bound of F and G is Function.
+    if (fTypeFormals.length != gTypeFormals.length) {
+      return typeProvider.functionType;
+    }
+
+    // If F and G differ in bounds of their of type parameters, then the
+    // least upper bound of F and G is Function.
+    var freshTypeFormalTypes =
+        FunctionTypeImpl.relateTypeFormals(f, g, (t, s, _, __) => t == s);
+    if (freshTypeFormalTypes == null) {
+      return typeProvider.functionType;
+    }
+
+    var typeFormals = freshTypeFormalTypes
+        .map<TypeParameterElement>((t) => t.element)
+        .toList();
+
+    f = f.instantiate(freshTypeFormalTypes);
+    g = g.instantiate(freshTypeFormalTypes);
+
     List<DartType> fRequired = f.normalParameterTypes;
     List<DartType> gRequired = g.normalParameterTypes;
 
@@ -2394,7 +2416,14 @@ abstract class TypeSystem implements public.TypeSystem {
 
     // Calculate the LUB of the return type.
     DartType returnType = getLeastUpperBound(f.returnType, g.returnType);
-    return new FunctionElementImpl.synthetic(parameters, returnType).type;
+
+    if (AnalysisDriver.useSummary2) {
+      return FunctionTypeImpl.synthetic(returnType, typeFormals, parameters);
+    }
+
+    var element = FunctionElementImpl.synthetic(parameters, returnType);
+    element.typeParameters = typeFormals;
+    return element.type;
   }
 
   /**