Consolidate the code that replaces a TypeParameter with its bound.

pkg/analyzer/test/src/dart/element/element_test.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 analyzer.test.src.dart.element.element_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
@@ skipping 1839 matching lines @@
         ElementFactory.functionTypeAliasElement('f');
     FunctionTypeAliasElementImpl g =
         ElementFactory.functionTypeAliasElement('g');
     f.typeParameters = [ElementFactory.typeParameterElement('T')];
     f.parameters = [ElementFactory.positionalParameter2('x', g.type)];
     FunctionTypeImpl paramType = f.type.optionalParameterTypes[0];
     expect(paramType.prunedTypedefs, hasLength(1));
     expect(paramType.prunedTypedefs[0], same(f));
   }
 
+  void test_resolveToBound() {
+    FunctionElementImpl f = ElementFactory.functionElement('f');
+    FunctionTypeImpl type = f.type;
+
+    // Returns this.
+    expect(type.resolveToBound(null), same(type));
+  }
+
   void test_returnType_pruned_no_type_arguments() {
     FunctionTypeAliasElementImpl f =
         ElementFactory.functionTypeAliasElement('f');
     FunctionTypeAliasElementImpl g =
         ElementFactory.functionTypeAliasElement('g');
     f.returnType = g.type;
     FunctionTypeImpl paramType = f.type.returnType;
     expect(paramType.prunedTypedefs, hasLength(1));
     expect(paramType.prunedTypedefs[0], same(f));
   }
@@ skipping 1515 matching lines @@
     //
     ClassElementImpl classA = ElementFactory.classElement2("A");
     InterfaceType typeA = classA.type;
     LibraryElementImpl library =
         ElementFactory.library(createAnalysisContext(), "lib");
     CompilationUnitElement unit = library.definingCompilationUnit;
     (unit as CompilationUnitElementImpl).types = <ClassElement>[classA];
     expect(typeA.lookUpSetter("s", library), isNull);
   }
 
+  void test_resolveToBound() {
+    InterfaceTypeImpl type =
+        ElementFactory.classElement2("A").type as InterfaceTypeImpl;
+
+    // Returns this.
+    expect(type.resolveToBound(null), same(type));
+  }
+
   void test_setTypeArguments() {
     InterfaceTypeImpl type =
         ElementFactory.classElement2("A").type as InterfaceTypeImpl;
     List<DartType> typeArguments = <DartType>[
       ElementFactory.classElement2("B").type,
       ElementFactory.classElement2("C").type
     ];
     type.typeArguments = typeArguments;
     expect(type.typeArguments, typeArguments);
   }
@@ skipping 524 matching lines @@
     TypeParameterElementImpl typeParameterT =
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("T"));
     typeParameterT.bound = classS.type;
     TypeParameterTypeImpl typeParameterTypeT =
         new TypeParameterTypeImpl(typeParameterT);
     // <T extends S>
     // T << S
     expect(typeParameterTypeT.isMoreSpecificThan(classS.type), isTrue);
   }
 
+  void test_resolveToBound_unbound() {
+    TypeParameterTypeImpl type = new TypeParameterTypeImpl(
+        new TypeParameterElementImpl.forNode(AstFactory.identifier3("E")));
+    // Returns whatever type is passed to resolveToBound().
+    expect(type.resolveToBound(VoidTypeImpl.instance),
+        same(VoidTypeImpl.instance));
+  }
+
+  void test_resolveToBound_bound() {
+    ClassElementImpl classS = ElementFactory.classElement2("A");
+    TypeParameterElementImpl element =
+    new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+    element.bound = classS.type;
+    TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
+    expect(type.resolveToBound(null), same(classS.type));
+  }
+
+  void test_resolveToBound_nestedBound() {
+    ClassElementImpl classS = ElementFactory.classElement2("A");
+    TypeParameterElementImpl elementE =
+    new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
+    elementE.bound = classS.type;
+    TypeParameterTypeImpl typeE = new TypeParameterTypeImpl(elementE);
+    TypeParameterElementImpl elementF =
+    new TypeParameterElementImpl.forNode(AstFactory.identifier3("F"));
+    elementF.bound = typeE;
+    TypeParameterTypeImpl typeF = new TypeParameterTypeImpl(elementE);
+    expect(typeF.resolveToBound(null), same(classS.type));
+  }
+
   void test_substitute_equal() {
     TypeParameterElementImpl element =
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
     InterfaceTypeImpl argument = new InterfaceTypeImpl(
         new ClassElementImpl.forNode(AstFactory.identifier3("A")));
     TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(element);
     expect(type.substitute2(<DartType>[argument], <DartType>[parameter]),
         same(argument));
   }
@@ skipping 39 matching lines @@
     expect(_voidType.isSubtypeOf(DynamicTypeImpl.instance), isTrue);
   }
 
   void test_isSubtypeOf_void_void() {
     expect(_voidType.isSubtypeOf(_voidType), isTrue);
   }
 
   void test_isVoid() {
     expect(_voidType.isVoid, isTrue);
   }
+
+  void test_resolveToBound() {
+    // Returns this.
+    expect(_voidType.resolveToBound(null), same(_voidType));
+  }
 }
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction
     extends InterfaceTypeImpl {
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }