diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index d3194eb8aa9..10a0c499d12 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -375,7 +375,6 @@ namespace ts {
             ResolvedBaseConstructorType,
             DeclaredType,
             ResolvedReturnType,
-            ResolvedDefault
         }
 
         const builtinGlobals = createMap<Symbol>();
@@ -2651,7 +2650,7 @@ namespace ts {
                     writeSpace(writer);
                     buildTypeDisplay(constraint, writer, enclosingDeclaration, flags, symbolStack);
                 }
-                const defaultType = getDefaultOfTypeParameter(tp);
+                const defaultType = getDefaultFromTypeParameter(tp);
                 if (defaultType) {
                     writeSpace(writer);
                     writePunctuation(writer, SyntaxKind.EqualsToken);
@@ -3054,9 +3053,6 @@ namespace ts {
             if (propertyName === TypeSystemPropertyName.ResolvedReturnType) {
                 return (<Signature>target).resolvedReturnType;
             }
-            if (propertyName === TypeSystemPropertyName.ResolvedDefault) {
-                return (<TypeVariable>target).resolvedDefault;
-            }
 
             Debug.fail("Unhandled TypeSystemPropertyName " + propertyName);
         }
@@ -4863,69 +4859,6 @@ namespace ts {
             return typeParameter.default === noConstraintOrDefaultType ? undefined : typeParameter.default;
         }
 
-        /**
-         * Gets the default type for a type parameter.
-         *
-         * If the type parameter is the result of an instantiation, this gets the instantiated
-         * default type of its target. If the type parameter has no default type, or if the default
-         * type circularly references the type parameter, `undefined` is returned.
-         *
-         * This function *does* perform a circularity check.
-         */
-        function getDefaultOfTypeParameter(typeParameter: TypeParameter): Type | undefined {
-            return hasNonCircularDefault(typeParameter) ? getDefaultFromTypeParameter(typeParameter) : undefined;
-        }
-
-        /**
-         * Determines whether a type parameter has a non-circular default type.
-         *
-         * Note that this function also returns `true` if a type parameter *does not* have a
-         * default type.
-         */
-        function hasNonCircularDefault(typeParameter: TypeParameter): boolean {
-            return getResolvedDefault(typeParameter) !== circularConstraintOrDefaultType;
-        }
-
-        /**
-         * Resolves the default type of a type parameter.
-         *
-         * If the type parameter has no default, the `noConstraintOrDefaultType` singleton is
-         * returned. If the type parameter has a circular default, the
-         * `circularConstraintOrDefaultType` singleton is returned.
-         */
-        function getResolvedDefault(typeParameter: TypeParameter): Type {
-            if (!typeParameter.resolvedDefault) {
-                if (!pushTypeResolution(typeParameter, TypeSystemPropertyName.ResolvedDefault)) {
-                    return circularConstraintOrDefaultType;
-                }
-                const defaultType = getDefaultFromTypeParameter(typeParameter);
-                const type = defaultType && getResolvedDefaultWorker(defaultType);
-                if (!popTypeResolution()) {
-                    return typeParameter.resolvedDefault = circularConstraintOrDefaultType;
-                }
-                typeParameter.resolvedDefault = type || noConstraintOrDefaultType;
-            }
-            return typeParameter.resolvedDefault;
-        }
-
-        /**
-         * Recursively resolves the default type for a type.
-         *
-         * If the type is a union or intersection type and any of its constituents is a circular
-         * reference, the `circularConstraintOrDefaultType` singleton is returned.
-         */
-        function getResolvedDefaultWorker(type: Type): Type {
-            if (type.flags & TypeFlags.TypeParameter) {
-                return getResolvedDefault(<TypeParameter>type);
-            }
-            if (type.flags & TypeFlags.UnionOrIntersection) {
-                const types = map((<UnionOrIntersectionType>type).types, getResolvedDefaultWorker);
-                return some(types, x => x === circularConstraintOrDefaultType) ? circularConstraintOrDefaultType :
-                    type.flags & TypeFlags.Union ? getUnionType(types) : getIntersectionType(types);
-            }
-            return type;
-        }
-
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
          * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
@@ -5241,20 +5174,23 @@ namespace ts {
                         typeArguments = [];
                     }
 
-                    // Map an unsatisfied type parameter with a default type to the default type.
+                    // Map an unsatisfied type parameter with a default type.
                     // If a type parameter does not have a default type, or if the default type
-                    // is a circular reference, the empty object type is used.
+                    // is a forward reference, the empty object type is used.
                     const mapper: TypeMapper = t => {
                         const i = indexOf(typeParameters, t);
-                        return i >= 0
-                            ? typeArguments[i] || (typeArguments[i] =
-                                instantiateType(getDefaultOfTypeParameter(typeParameters[i]), mapper) ||
-                                emptyObjectType)
-                            : t;
+                        if (i >= typeArguments.length) {
+                            return emptyObjectType;
+                        }
+                        if (i >= 0) {
+                            return typeArguments[i];
+                        }
+                        return t;
                     };
 
                     for (let i = numTypeArguments; i < numTypeParameters; i++) {
-                        instantiateType(typeParameters[i], mapper);
+                        const defaultType = getDefaultFromTypeParameter(typeParameters[i]);
+                        typeArguments[i] = defaultType ? instantiateType(defaultType, mapper) : emptyObjectType;
                     }
                 }
             }
@@ -9181,8 +9117,16 @@ namespace ts {
                     // succeeds, meaning there is no error for not having inference candidates. An
                     // inference error only occurs when there are *conflicting* candidates, i.e.
                     // candidates with no common supertype.
-                    const defaultType = getDefaultOfTypeParameter(context.signature.typeParameters[index]);
-                    inferredType = defaultType ? instantiateType(defaultType, getInferenceMapper(context)) : emptyObjectType;
+                    const defaultType = getDefaultFromTypeParameter(context.signature.typeParameters[index]);
+                    if (defaultType) {
+                        const backreferenceMapper: TypeMapper = t => indexOf(context.signature.typeParameters, t) >= index ? emptyObjectType : t;
+                        const mapper = combineTypeMappers(backreferenceMapper, getInferenceMapper(context));
+                        inferredType = instantiateType(defaultType, mapper);
+                    }
+                    else {
+                        inferredType = emptyObjectType;
+                    }
+
                     inferenceSucceeded = true;
                 }
                 context.inferredTypes[index] = inferredType;
@@ -15574,11 +15518,8 @@ namespace ts {
             if (!hasNonCircularBaseConstraint(typeParameter)) {
                 error(node.constraint, Diagnostics.Type_parameter_0_has_a_circular_constraint, typeToString(typeParameter));
             }
-            if (!hasNonCircularDefault(typeParameter)) {
-                error(node.default, Diagnostics.Type_parameter_0_has_a_circular_default, typeToString(typeParameter));
-            }
             const constraintType = getConstraintOfTypeParameter(typeParameter);
-            const defaultType = getDefaultOfTypeParameter(typeParameter);
+            const defaultType = getDefaultFromTypeParameter(typeParameter);
             if (constraintType && defaultType) {
                 checkTypeAssignableTo(defaultType, getTypeWithThisArgument(constraintType, defaultType), node.default, Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
             }
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index ca4162804d0..eeedac3c1a9 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -2043,11 +2043,7 @@
         "category": "Error",
         "code": 2705
     },
-     "Type parameter '{0}' has a circular default.": {
-        "category": "Error",
-        "code": 2706
-    },
-     "Generic type '{0}' requires between {1} and {2} type arguments.": {
+    "Generic type '{0}' requires between {1} and {2} type arguments.": {
         "category": "Error",
         "code": 2707
     },
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 30a054d481e..0e987e53b4f 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2990,8 +2990,6 @@ namespace ts {
         /* @internal */
         resolvedBaseConstraint: Type;
         /* @internal */
-        resolvedDefault: Type;
-        /* @internal */
         resolvedIndexType: IndexType;
     }
 
diff --git a/tests/baselines/reference/genericDefaults.js b/tests/baselines/reference/genericDefaults.js
index 496c3894817..0f59bcfd051 100644
--- a/tests/baselines/reference/genericDefaults.js
+++ b/tests/baselines/reference/genericDefaults.js
@@ -1,68 +1,398 @@
 //// [genericDefaults.ts]
+interface A { a: number; }
+interface B { b: number; }
+interface C { c: number; }
+interface D { d: number; }
+interface AB { a: number; b: number; }
+interface BC { b: number; c: number; }
+
+declare const a: A;
+declare const b: B;
+declare const c: C;
+declare const d: D;
+declare const ab: AB;
+declare const bc: BC;
 declare const x: any;
 
-declare function f00<T = number>(a?: T): T;
-const f00c00 = f00();
-const f00c01 = f00(1);
-const f00c02 = f00("a");
-const f00c03 = f00<number>();
-const f00c04 = f00<number>(1);
-const f00c05 = f00<string>("a");
+// function without type parameters
+declare function f00(a?: A): A;
+// no inference
+f00();
+f00(a);
 
-declare function f01<T, U = T>(a?: T, b?: U): [T, U];
-const f01c00 = f01();
-const f01c01 = f01(1);
-const f01c02 = f01(1, "a");
-const f01c03 = f01<number>();
-const f01c04 = f01<number>(1);
-const f01c05 = f01<number>(1, 2);
-const f01c06 = f01<number, string>();
-const f01c07 = f01<number, string>(1);
-const f01c08 = f01<number, string>(1, "a");
+// function with a type parameter without a default
+declare function f01<T>(a?: T): T;
+// inference
+f01();
+f01(a);
+// no inference, fully supplied
+f01<A>();
+f01<A>(a);
 
-declare function f02<T extends number, U = T>(a?: T, b?: U): [T, U];
-const f02c00 = f02();
-const f02c01 = f02(1);
-const f02c02 = f02(1, "a");
-const f02c03 = f02<number>();
-const f02c04 = f02<number>(1);
-const f02c05 = f02<number>(1, 2);
-const f02c06 = f02<number, string>();
-const f02c07 = f02<number, string>(1);
-const f02c08 = f02<number, string>(1, "a");
+// function with a type paramter with a default
+declare function f02<T = A>(a?: T): T;
+// inference
+f02();
+f02(a);
+f02(b);
+// no inference, fully supplied
+f02<A>();
+f02<A>(a);
+f02<B>();
+f02<B>(b);
 
-declare function f03<T extends number, U extends T = T>(a?: T, b?: U): [T, U];
-const f03c00 = f03();
-const f03c01 = f03(1);
-const f03c02 = f03(1, 1);
-const f03c03 = f03<number>();
-const f03c04 = f03<number>(1);
-const f03c05 = f03<number>(1, 2);
-const f03c06 = f03<number, number>();
-const f03c07 = f03<number, number>(1);
-const f03c08 = f03<number, number>(1, 2);
+// function with a type parameter with a default that refers to itself
+declare function f03<T = T>(a?: T): T;
+// inference
+f03();
+f03(a);
+f03(b);
+// no inference, fully supplied
+f03<A>();
+f03<A>(a);
+f03<B>();
+f03<B>(b);
 
-declare function f04<T, U = T | { a: number }>(a?: T, b?: U): [T, U];
-const f04c00 = f04();
-const f04c01 = f04(1);
-const f04c02 = f04(1, 1);
-const f04c03 = f04<number>();
-const f04c04 = f04<number>(1);
-const f04c05 = f04<number>(1, 2);
-const f04c06 = f04<number, number>();
-const f04c07 = f04<number, number>(1);
-const f04c08 = f04<number, number>(1, 2);
+// function with a type paramter without a default and a type parameter with a default
+declare function f04<T, U = B>(a?: T, b?: U): [T, U];
+// inference
+f04();
+f04(a);
+f04(a, b);
+f04(a, c);
+// no inference, partially supplied
+f04<A>();
+f04<A>(a);
+f04<A>(a, b);
+// no inference, fully supplied
+f04<A, B>();
+f04<A, B>(a);
+f04<A, B>(a, b);
+f04<A, C>();
+f04<A, C>(a);
+f04<A, C>(a, c);
 
-declare function f05<T, U = T & { b: number }>(a?: T, b?: U): [T, U];
-const f05c00 = f05();
-const f05c01 = f05(1);
-const f05c02 = f05(1, 1);
-const f05c03 = f05<number>();
-const f05c04 = f05<number>(1);
-const f05c05 = f05<{ a: number }>({ a: 1 }, { a: 2, b: 3});
-const f05c06 = f05<number, number>();
-const f05c07 = f05<number, number>(1);
-const f05c08 = f05<number, number>(1, 2);
+// function with a type parameter without a default and a type parameter with a default that refers to an earlier type parameter
+declare function f05<T, U = T>(a?: T, b?: U): [T, U];
+// inference
+f05();
+f05(a);
+f05(a, a);
+f05(a, b);
+// no inference, partially supplied
+f05<A>();
+f05<A>(a);
+f05<A>(a, a);
+// no inference, fully supplied
+f05<A, B>();
+f05<A, B>(a);
+f05<A, B>(a, b);
+
+// function with a type parameter with a default that refers to an earlier type parameter with a default
+declare function f06<T = A, U = T>(a?: T, b?: U): [T, U];
+// inference
+f06();
+f06(a);
+f06(a, a);
+f06(a, b);
+f06(b, a);
+f06(b, b);
+// no inference, partially supplied
+f06<A>();
+f06<A>(a);
+f06<A>(a, a);
+f06<B>();
+f06<B>(b);
+f06<B>(b, b);
+// no inference, fully supplied
+f06<A, B>();
+f06<A, B>(a);
+f06<A, B>(a, b);
+f06<B, C>();
+f06<B, C>(b);
+f06<B, C>(b, c);
+
+// function with a type parameter without a default and a type parameter with a default that refers to an earlier type parameter with a default
+declare function f07<T, U = B, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+// inference
+f07();
+f07(a, b);
+f07(a, c);
+f07(a, b, b);
+f07(a, b, c);
+f07(a, c, b);
+f07(a, c, c);
+// no inference, partially supplied
+f07<A>();
+f07<A>(a);
+f07<A>(a, b);
+f07<A>(a, b, b);
+f07<A, B>();
+f07<A, B>(a);
+f07<A, B>(a, b);
+f07<A, B>(a, b, b);
+f07<A, C>();
+f07<A, C>(a);
+f07<A, C>(a, c);
+f07<A, C>(a, c, c);
+// no inference, fully supplied
+f07<A, B, C>();
+f07<A, B, C>(a);
+f07<A, B, C>(a, b);
+f07<A, B, C>(a, b, c);
+f07<A, C, A>();
+f07<A, C, A>(a);
+f07<A, C, D>(a, c);
+f07<A, C, D>(a, c, d);
+
+// function with a type parameter with a default that refers to an earlier type parameter with a constraint
+declare function f08<T extends A, U = T>(a?: T, b?: U): [T, U];
+// inference
+f08();
+f08(a);
+f08(a, a);
+f08(a, b);
+// no inference, partially supplied
+f08<A>();
+f08<A>(a);
+f08<A>(a, a);
+// no inference, fully supplied
+f08<A, B>();
+f08<A, B>(a);
+f08<A, B>(a, b);
+
+// function with a type parameter with a constraint and a default that refers to an earlier type parameter
+declare function f09<T, U extends T = T>(a?: T, b?: U): [T, U];
+// inference
+f09();
+f09(a);
+f09(a, a);
+f09(a, ab);
+// no inference, partially supplied
+f09<A>();
+f09<A>(a);
+f09<A>(a, a);
+f09<A>(a, ab);
+// no inference, fully supplied
+f09<A, AB>();
+f09<A, AB>(a);
+f09<A, AB>(a, ab);
+
+// function with a type parameter with a constraint and a default that refers to an earlier type parameter with a constraint
+declare function f10<T extends A, U extends T = T>(a?: T, b?: U): [T, U];
+// inference
+f10();
+f10(a);
+f10(a, a);
+f10(a, ab);
+// no inference, partially supplied
+f10<A>();
+f10<A>(a);
+f10<A>(a, a);
+f10<A>(a, ab);
+// no inference, fully supplied
+f10<A, A>();
+f10<A, A>(a);
+f10<A, A>(a, a);
+f10<A, A>(a, ab);
+f10<A, AB>();
+f10<A, AB>(a);
+f10<A, AB>(a, ab);
+
+// function with a type parameter with a default that refers to an earier type parameter in a union
+declare function f11<T, U = T | B>(a?: T, b?: U): [T, U];
+// inference
+f11();
+f11(a);
+f11(a, a);
+f11(a, b);
+f11(a, c);
+// no inference, partially supplied
+f11<A>();
+f11<A>(a);
+f11<A>(a, a);
+f11<A>(a, b);
+// no inference, fully supplied
+f11<A, C>();
+f11<A, C>(a);
+f11<A, C>(a, c);
+
+// function with a type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f12<T, U = T & B>(a?: T, b?: U): [T, U];
+// inference
+f12();
+f12(a);
+f12(a, a);
+f12(a, b);
+f12(a, c);
+// no inference, partially supplied
+f12<A>();
+f12<A>(a);
+f12<A>(a, ab);
+// no inference, fully supplied
+f12<A, C>();
+f12<A, C>(a);
+f12<A, C>(a, c);
+
+// function with a type parameter with a default that refers to a later type parameter with a default
+declare function f13<T = U, U = B>(a?: T, b?: U): [T, U];
+// inference
+f13();
+f13(a);
+f13(a, b);
+f13(a, c);
+// no inference, partially supplied
+f13<A>();
+f13<A>(a);
+f13<A>(a, b);
+// no inference, fully supplied
+f13<A, C>();
+f13<A, C>(a);
+f13<A, C>(a, c);
+f13<A, C>(a, c);
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default
+declare function f14<T, U = V, V = C>(a?: T, b?: U, c?: V): [T, U, V];
+// inference
+f14();
+f14(a);
+f14(a, b);
+f14(a, b, c);
+f14(a, b, d);
+// no inference, partially supplied
+f14<A>();
+f14<A>(a);
+f14<A>(a, b);
+f14<A>(a, b, c);
+f14<A, B>();
+f14<A, B>(a);
+f14<A, B>(a, b);
+f14<A, B>(a, b, c);
+// no inference fully supplied
+f14<A, B, D>();
+f14<A, B, D>(a);
+f14<A, B, D>(a, b);
+f14<A, B, D>(a, b, d);
+
+// function with two type parameters with defaults that mutually refer to each other
+declare function f15<T = U, U = T>(a?: T, b?: U): [T, U];
+// inference
+f15();
+f15(a);
+f15(a, b);
+// no inference, partially supplied
+f15<A>();
+f15<A>(a);
+f15<A>(a, a);
+// no inference, fully supplied
+f15<A, B>();
+f15<A, B>(a);
+f15<A, B>(a, b);
+
+// function with a type parameter without a default and two type parameters with defaults that mutually refer to each other
+declare function f16<T, U = V, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+// no inference
+f16();
+f16(a);
+f16(a, b);
+f16(a, b, b);
+// no inference, partially supplied
+f16<A>();
+f16<A>(a);
+f16<A>(a, b);
+f16<A>(a, b, b);
+f16<A, B>();
+f16<A, B>(a);
+f16<A, B>(a, b);
+f16<A, B>(a, b, b);
+// no inference, fully supplied
+f16<A, B, D>();
+f16<A, B, D>(a);
+f16<A, B, D>(a, b);
+f16<A, B, D>(a, b, d);
+
+// function with a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in a union
+declare function f17<T = U, U = T | B>(a?: T, b?: U): [T, U];
+// inference
+f17();
+f17(a);
+f17(a, a);
+f17(a, b);
+f17(a, c);
+// no inference, partially supplied
+f17<A>();
+f17<A>(a);
+f17<A>(a, a);
+f17<A>(a, b);
+// no inference, fully supplied
+f17<A, C>();
+f17<A, C>(a);
+f17<A, C>(a, c);
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in a union
+declare function f18<T, U = V, V = U | C>(a?: T, b?: U, c?: V): [T, U, V];
+// inference
+f18();
+f18(a);
+f18(a, b);
+f18(a, b, b);
+f18(a, b, c);
+// no inference, partially supplied
+f18<A>();
+f18<A>(a);
+f18<A>(a, b);
+f18<A>(a, b, b);
+f18<A>(a, b, c);
+f18<A, B>();
+f18<A, B>(a);
+f18<A, B>(a, b);
+f18<A, B>(a, b, b);
+f18<A, B>(a, b, c);
+// no inference, fully supplied
+f18<A, B, D>();
+f18<A, B, D>(a);
+f18<A, B, D>(a, b);
+f18<A, B, D>(a, b, d);
+
+// function with a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f19<T = U, U = T & B>(a?: T, b?: U): [T, U];
+// inference
+f19();
+f19(a);
+f19(a, a);
+f19(a, b);
+f19(a, ab);
+f19(a, c);
+// no inference, partially supplied
+f19<A>();
+f19<A>(a);
+f19<A>(a, ab);
+// no inference, fully supplied
+f19<A, C>();
+f19<A, C>(a);
+f19<A, C>(a, c);
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f20<T, U = V, V = U & C>(a?: T, b?: U, c?: V): [T, U, V];
+// inference
+f20();
+f20(a);
+f20(a, b);
+f20(a, b, c);
+// no inference, partially supplied
+f20<A>();
+f20<A>(a);
+f20<A>(a, b);
+f20<A>(a, b, bc);
+f20<A, B>();
+f20<A, B>(a);
+f20<A, B>(a, b);
+f20<A, B>(a, b, bc);
+// no inference, fully supplied
+f20<A, B, D>();
+f20<A, B, D>(a);
+f20<A, B, D>(a, b);
+f20<A, B, D>(a, b, d);
 
 interface i00<T = number> { a: T; }
 const i00c00 = (<i00>x).a;
@@ -91,6 +421,15 @@ interface i04<T> {}
 interface i04<T = number> {}
 interface i04<T = number, U = string> {}
 
+interface i05<T = T> { a: T; }
+const i05c00 = (<i05>x).a;
+const i05c01 = (<i05<number>>x).a;
+
+interface i06<T = U, U = T> { a: [T, U]; }
+const i06c00 = (<i06>x).a;
+const i06c01 = (<i06<number>>x).a;
+const i06c02 = (<i06<number, string>>x).a;
+
 interface Base01<T> { a: T; }
 interface Base01Constructor { new <T = number>(a?: T): Base01<T>; }
 
@@ -114,57 +453,323 @@ const Derived02c03 = new Derived02<number>(1);
 
 
 //// [genericDefaults.js]
-var f00c00 = f00();
-var f00c01 = f00(1);
-var f00c02 = f00("a");
-var f00c03 = f00();
-var f00c04 = f00(1);
-var f00c05 = f00("a");
-var f01c00 = f01();
-var f01c01 = f01(1);
-var f01c02 = f01(1, "a");
-var f01c03 = f01();
-var f01c04 = f01(1);
-var f01c05 = f01(1, 2);
-var f01c06 = f01();
-var f01c07 = f01(1);
-var f01c08 = f01(1, "a");
-var f02c00 = f02();
-var f02c01 = f02(1);
-var f02c02 = f02(1, "a");
-var f02c03 = f02();
-var f02c04 = f02(1);
-var f02c05 = f02(1, 2);
-var f02c06 = f02();
-var f02c07 = f02(1);
-var f02c08 = f02(1, "a");
-var f03c00 = f03();
-var f03c01 = f03(1);
-var f03c02 = f03(1, 1);
-var f03c03 = f03();
-var f03c04 = f03(1);
-var f03c05 = f03(1, 2);
-var f03c06 = f03();
-var f03c07 = f03(1);
-var f03c08 = f03(1, 2);
-var f04c00 = f04();
-var f04c01 = f04(1);
-var f04c02 = f04(1, 1);
-var f04c03 = f04();
-var f04c04 = f04(1);
-var f04c05 = f04(1, 2);
-var f04c06 = f04();
-var f04c07 = f04(1);
-var f04c08 = f04(1, 2);
-var f05c00 = f05();
-var f05c01 = f05(1);
-var f05c02 = f05(1, 1);
-var f05c03 = f05();
-var f05c04 = f05(1);
-var f05c05 = f05({ a: 1 }, { a: 2, b: 3 });
-var f05c06 = f05();
-var f05c07 = f05(1);
-var f05c08 = f05(1, 2);
+// no inference
+f00();
+f00(a);
+// inference
+f01();
+f01(a);
+// no inference, fully supplied
+f01();
+f01(a);
+// inference
+f02();
+f02(a);
+f02(b);
+// no inference, fully supplied
+f02();
+f02(a);
+f02();
+f02(b);
+// inference
+f03();
+f03(a);
+f03(b);
+// no inference, fully supplied
+f03();
+f03(a);
+f03();
+f03(b);
+// inference
+f04();
+f04(a);
+f04(a, b);
+f04(a, c);
+// no inference, partially supplied
+f04();
+f04(a);
+f04(a, b);
+// no inference, fully supplied
+f04();
+f04(a);
+f04(a, b);
+f04();
+f04(a);
+f04(a, c);
+// inference
+f05();
+f05(a);
+f05(a, a);
+f05(a, b);
+// no inference, partially supplied
+f05();
+f05(a);
+f05(a, a);
+// no inference, fully supplied
+f05();
+f05(a);
+f05(a, b);
+// inference
+f06();
+f06(a);
+f06(a, a);
+f06(a, b);
+f06(b, a);
+f06(b, b);
+// no inference, partially supplied
+f06();
+f06(a);
+f06(a, a);
+f06();
+f06(b);
+f06(b, b);
+// no inference, fully supplied
+f06();
+f06(a);
+f06(a, b);
+f06();
+f06(b);
+f06(b, c);
+// inference
+f07();
+f07(a, b);
+f07(a, c);
+f07(a, b, b);
+f07(a, b, c);
+f07(a, c, b);
+f07(a, c, c);
+// no inference, partially supplied
+f07();
+f07(a);
+f07(a, b);
+f07(a, b, b);
+f07();
+f07(a);
+f07(a, b);
+f07(a, b, b);
+f07();
+f07(a);
+f07(a, c);
+f07(a, c, c);
+// no inference, fully supplied
+f07();
+f07(a);
+f07(a, b);
+f07(a, b, c);
+f07();
+f07(a);
+f07(a, c);
+f07(a, c, d);
+// inference
+f08();
+f08(a);
+f08(a, a);
+f08(a, b);
+// no inference, partially supplied
+f08();
+f08(a);
+f08(a, a);
+// no inference, fully supplied
+f08();
+f08(a);
+f08(a, b);
+// inference
+f09();
+f09(a);
+f09(a, a);
+f09(a, ab);
+// no inference, partially supplied
+f09();
+f09(a);
+f09(a, a);
+f09(a, ab);
+// no inference, fully supplied
+f09();
+f09(a);
+f09(a, ab);
+// inference
+f10();
+f10(a);
+f10(a, a);
+f10(a, ab);
+// no inference, partially supplied
+f10();
+f10(a);
+f10(a, a);
+f10(a, ab);
+// no inference, fully supplied
+f10();
+f10(a);
+f10(a, a);
+f10(a, ab);
+f10();
+f10(a);
+f10(a, ab);
+// inference
+f11();
+f11(a);
+f11(a, a);
+f11(a, b);
+f11(a, c);
+// no inference, partially supplied
+f11();
+f11(a);
+f11(a, a);
+f11(a, b);
+// no inference, fully supplied
+f11();
+f11(a);
+f11(a, c);
+// inference
+f12();
+f12(a);
+f12(a, a);
+f12(a, b);
+f12(a, c);
+// no inference, partially supplied
+f12();
+f12(a);
+f12(a, ab);
+// no inference, fully supplied
+f12();
+f12(a);
+f12(a, c);
+// inference
+f13();
+f13(a);
+f13(a, b);
+f13(a, c);
+// no inference, partially supplied
+f13();
+f13(a);
+f13(a, b);
+// no inference, fully supplied
+f13();
+f13(a);
+f13(a, c);
+f13(a, c);
+// inference
+f14();
+f14(a);
+f14(a, b);
+f14(a, b, c);
+f14(a, b, d);
+// no inference, partially supplied
+f14();
+f14(a);
+f14(a, b);
+f14(a, b, c);
+f14();
+f14(a);
+f14(a, b);
+f14(a, b, c);
+// no inference fully supplied
+f14();
+f14(a);
+f14(a, b);
+f14(a, b, d);
+// inference
+f15();
+f15(a);
+f15(a, b);
+// no inference, partially supplied
+f15();
+f15(a);
+f15(a, a);
+// no inference, fully supplied
+f15();
+f15(a);
+f15(a, b);
+// no inference
+f16();
+f16(a);
+f16(a, b);
+f16(a, b, b);
+// no inference, partially supplied
+f16();
+f16(a);
+f16(a, b);
+f16(a, b, b);
+f16();
+f16(a);
+f16(a, b);
+f16(a, b, b);
+// no inference, fully supplied
+f16();
+f16(a);
+f16(a, b);
+f16(a, b, d);
+// inference
+f17();
+f17(a);
+f17(a, a);
+f17(a, b);
+f17(a, c);
+// no inference, partially supplied
+f17();
+f17(a);
+f17(a, a);
+f17(a, b);
+// no inference, fully supplied
+f17();
+f17(a);
+f17(a, c);
+// inference
+f18();
+f18(a);
+f18(a, b);
+f18(a, b, b);
+f18(a, b, c);
+// no inference, partially supplied
+f18();
+f18(a);
+f18(a, b);
+f18(a, b, b);
+f18(a, b, c);
+f18();
+f18(a);
+f18(a, b);
+f18(a, b, b);
+f18(a, b, c);
+// no inference, fully supplied
+f18();
+f18(a);
+f18(a, b);
+f18(a, b, d);
+// inference
+f19();
+f19(a);
+f19(a, a);
+f19(a, b);
+f19(a, ab);
+f19(a, c);
+// no inference, partially supplied
+f19();
+f19(a);
+f19(a, ab);
+// no inference, fully supplied
+f19();
+f19(a);
+f19(a, c);
+// inference
+f20();
+f20(a);
+f20(a, b);
+f20(a, b, c);
+// no inference, partially supplied
+f20();
+f20(a);
+f20(a, b);
+f20(a, b, bc);
+f20();
+f20(a);
+f20(a, b);
+f20(a, b, bc);
+// no inference, fully supplied
+f20();
+f20(a);
+f20(a, b);
+f20(a, b, d);
 var i00c00 = x.a;
 var i00c01 = x.a;
 var i01c00 = x.a;
@@ -179,6 +784,11 @@ var i03c01 = x.a;
 var i03c02 = x.a;
 var i03c03 = x.a;
 var i03c04 = x.a;
+var i05c00 = x.a;
+var i05c01 = x.a;
+var i06c00 = x.a;
+var i06c01 = x.a;
+var i06c02 = x.a;
 var Base01c00 = new Base01();
 var Base01c01 = new Base01(1);
 var Base01c02 = new Base01();
@@ -194,92 +804,54 @@ var Derived02c03 = new Derived02(1);
 
 
 //// [genericDefaults.d.ts]
+interface A {
+    a: number;
+}
+interface B {
+    b: number;
+}
+interface C {
+    c: number;
+}
+interface D {
+    d: number;
+}
+interface AB {
+    a: number;
+    b: number;
+}
+interface BC {
+    b: number;
+    c: number;
+}
+declare const a: A;
+declare const b: B;
+declare const c: C;
+declare const d: D;
+declare const ab: AB;
+declare const bc: BC;
 declare const x: any;
-declare function f00<T = number>(a?: T): T;
-declare const f00c00: number;
-declare const f00c01 = 1;
-declare const f00c02 = "a";
-declare const f00c03: number;
-declare const f00c04: number;
-declare const f00c05: string;
-declare function f01<T, U = T>(a?: T, b?: U): [T, U];
-declare const f01c00: [{}, {}];
-declare const f01c01: [number, number];
-declare const f01c02: [number, string];
-declare const f01c03: [number, number];
-declare const f01c04: [number, number];
-declare const f01c05: [number, number];
-declare const f01c06: [number, string];
-declare const f01c07: [number, string];
-declare const f01c08: [number, string];
-declare function f02<T extends number, U = T>(a?: T, b?: U): [T, U];
-declare const f02c00: [number, number];
-declare const f02c01: [1, 1];
-declare const f02c02: [1, string];
-declare const f02c03: [number, number];
-declare const f02c04: [number, number];
-declare const f02c05: [number, number];
-declare const f02c06: [number, string];
-declare const f02c07: [number, string];
-declare const f02c08: [number, string];
-declare function f03<T extends number, U extends T = T>(a?: T, b?: U): [T, U];
-declare const f03c00: [number, number];
-declare const f03c01: [1, 1];
-declare const f03c02: [1, 1];
-declare const f03c03: [number, number];
-declare const f03c04: [number, number];
-declare const f03c05: [number, number];
-declare const f03c06: [number, number];
-declare const f03c07: [number, number];
-declare const f03c08: [number, number];
-declare function f04<T, U = T | {
-    a: number;
-}>(a?: T, b?: U): [T, U];
-declare const f04c00: [{}, {} | {
-    a: number;
-}];
-declare const f04c01: [number, number | {
-    a: number;
-}];
-declare const f04c02: [number, number];
-declare const f04c03: [number, number | {
-    a: number;
-}];
-declare const f04c04: [number, number | {
-    a: number;
-}];
-declare const f04c05: [number, number | {
-    a: number;
-}];
-declare const f04c06: [number, number];
-declare const f04c07: [number, number];
-declare const f04c08: [number, number];
-declare function f05<T, U = T & {
-    b: number;
-}>(a?: T, b?: U): [T, U];
-declare const f05c00: [{}, {} & {
-    b: number;
-}];
-declare const f05c01: [number, number & {
-    b: number;
-}];
-declare const f05c02: [number, number];
-declare const f05c03: [number, number & {
-    b: number;
-}];
-declare const f05c04: [number, number & {
-    b: number;
-}];
-declare const f05c05: [{
-    a: number;
-}, {
-    a: number;
-} & {
-    b: number;
-}];
-declare const f05c06: [number, number];
-declare const f05c07: [number, number];
-declare const f05c08: [number, number];
+declare function f00(a?: A): A;
+declare function f01<T>(a?: T): T;
+declare function f02<T = A>(a?: T): T;
+declare function f03<T = T>(a?: T): T;
+declare function f04<T, U = B>(a?: T, b?: U): [T, U];
+declare function f05<T, U = T>(a?: T, b?: U): [T, U];
+declare function f06<T = A, U = T>(a?: T, b?: U): [T, U];
+declare function f07<T, U = B, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+declare function f08<T extends A, U = T>(a?: T, b?: U): [T, U];
+declare function f09<T, U extends T = T>(a?: T, b?: U): [T, U];
+declare function f10<T extends A, U extends T = T>(a?: T, b?: U): [T, U];
+declare function f11<T, U = T | B>(a?: T, b?: U): [T, U];
+declare function f12<T, U = T & B>(a?: T, b?: U): [T, U];
+declare function f13<T = U, U = B>(a?: T, b?: U): [T, U];
+declare function f14<T, U = V, V = C>(a?: T, b?: U, c?: V): [T, U, V];
+declare function f15<T = U, U = T>(a?: T, b?: U): [T, U];
+declare function f16<T, U = V, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+declare function f17<T = U, U = T | B>(a?: T, b?: U): [T, U];
+declare function f18<T, U = V, V = U | C>(a?: T, b?: U, c?: V): [T, U, V];
+declare function f19<T = U, U = T & B>(a?: T, b?: U): [T, U];
+declare function f20<T, U = V, V = U & C>(a?: T, b?: U, c?: V): [T, U, V];
 interface i00<T = number> {
     a: T;
 }
@@ -314,6 +886,17 @@ interface i04<T = number> {
 }
 interface i04<T = number, U = string> {
 }
+interface i05<T = T> {
+    a: T;
+}
+declare const i05c00: {};
+declare const i05c01: number;
+interface i06<T = U, U = T> {
+    a: [T, U];
+}
+declare const i06c00: [{}, {}];
+declare const i06c01: [number, number];
+declare const i06c02: [number, string];
 interface Base01<T> {
     a: T;
 }
diff --git a/tests/baselines/reference/genericDefaults.symbols b/tests/baselines/reference/genericDefaults.symbols
index 0a633e60612..ea0f280a1f1 100644
--- a/tests/baselines/reference/genericDefaults.symbols
+++ b/tests/baselines/reference/genericDefaults.symbols
@@ -1,508 +1,2084 @@
 === tests/cases/compiler/genericDefaults.ts ===
+interface A { a: number; }
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(A.a, Decl(genericDefaults.ts, 0, 13))
+
+interface B { b: number; }
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>b : Symbol(B.b, Decl(genericDefaults.ts, 1, 13))
+
+interface C { c: number; }
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>c : Symbol(C.c, Decl(genericDefaults.ts, 2, 13))
+
+interface D { d: number; }
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>d : Symbol(D.d, Decl(genericDefaults.ts, 3, 13))
+
+interface AB { a: number; b: number; }
+>AB : Symbol(AB, Decl(genericDefaults.ts, 3, 26))
+>a : Symbol(AB.a, Decl(genericDefaults.ts, 4, 14))
+>b : Symbol(AB.b, Decl(genericDefaults.ts, 4, 25))
+
+interface BC { b: number; c: number; }
+>BC : Symbol(BC, Decl(genericDefaults.ts, 4, 38))
+>b : Symbol(BC.b, Decl(genericDefaults.ts, 5, 14))
+>c : Symbol(BC.c, Decl(genericDefaults.ts, 5, 25))
+
+declare const a: A;
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+declare const b: B;
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+declare const c: C;
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+declare const d: D;
+>d : Symbol(d, Decl(genericDefaults.ts, 10, 13))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+
+declare const ab: AB;
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+>AB : Symbol(AB, Decl(genericDefaults.ts, 3, 26))
+
+declare const bc: BC;
+>bc : Symbol(bc, Decl(genericDefaults.ts, 12, 13))
+>BC : Symbol(BC, Decl(genericDefaults.ts, 4, 38))
+
 declare const x: any;
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
 
-declare function f00<T = number>(a?: T): T;
->f00 : Symbol(f00, Decl(genericDefaults.ts, 0, 21))
->T : Symbol(T, Decl(genericDefaults.ts, 2, 21))
->a : Symbol(a, Decl(genericDefaults.ts, 2, 33))
->T : Symbol(T, Decl(genericDefaults.ts, 2, 21))
->T : Symbol(T, Decl(genericDefaults.ts, 2, 21))
+// function without type parameters
+declare function f00(a?: A): A;
+>f00 : Symbol(f00, Decl(genericDefaults.ts, 13, 21))
+>a : Symbol(a, Decl(genericDefaults.ts, 16, 21))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
 
-const f00c00 = f00();
->f00c00 : Symbol(f00c00, Decl(genericDefaults.ts, 3, 5))
->f00 : Symbol(f00, Decl(genericDefaults.ts, 0, 21))
+// no inference
+f00();
+>f00 : Symbol(f00, Decl(genericDefaults.ts, 13, 21))
 
-const f00c01 = f00(1);
->f00c01 : Symbol(f00c01, Decl(genericDefaults.ts, 4, 5))
->f00 : Symbol(f00, Decl(genericDefaults.ts, 0, 21))
+f00(a);
+>f00 : Symbol(f00, Decl(genericDefaults.ts, 13, 21))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f00c02 = f00("a");
->f00c02 : Symbol(f00c02, Decl(genericDefaults.ts, 5, 5))
->f00 : Symbol(f00, Decl(genericDefaults.ts, 0, 21))
+// function with a type parameter without a default
+declare function f01<T>(a?: T): T;
+>f01 : Symbol(f01, Decl(genericDefaults.ts, 19, 7))
+>T : Symbol(T, Decl(genericDefaults.ts, 22, 21))
+>a : Symbol(a, Decl(genericDefaults.ts, 22, 24))
+>T : Symbol(T, Decl(genericDefaults.ts, 22, 21))
+>T : Symbol(T, Decl(genericDefaults.ts, 22, 21))
 
-const f00c03 = f00<number>();
->f00c03 : Symbol(f00c03, Decl(genericDefaults.ts, 6, 5))
->f00 : Symbol(f00, Decl(genericDefaults.ts, 0, 21))
+// inference
+f01();
+>f01 : Symbol(f01, Decl(genericDefaults.ts, 19, 7))
 
-const f00c04 = f00<number>(1);
->f00c04 : Symbol(f00c04, Decl(genericDefaults.ts, 7, 5))
->f00 : Symbol(f00, Decl(genericDefaults.ts, 0, 21))
+f01(a);
+>f01 : Symbol(f01, Decl(genericDefaults.ts, 19, 7))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f00c05 = f00<string>("a");
->f00c05 : Symbol(f00c05, Decl(genericDefaults.ts, 8, 5))
->f00 : Symbol(f00, Decl(genericDefaults.ts, 0, 21))
+// no inference, fully supplied
+f01<A>();
+>f01 : Symbol(f01, Decl(genericDefaults.ts, 19, 7))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
 
-declare function f01<T, U = T>(a?: T, b?: U): [T, U];
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
->T : Symbol(T, Decl(genericDefaults.ts, 10, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 10, 23))
->T : Symbol(T, Decl(genericDefaults.ts, 10, 21))
->a : Symbol(a, Decl(genericDefaults.ts, 10, 31))
->T : Symbol(T, Decl(genericDefaults.ts, 10, 21))
->b : Symbol(b, Decl(genericDefaults.ts, 10, 37))
->U : Symbol(U, Decl(genericDefaults.ts, 10, 23))
->T : Symbol(T, Decl(genericDefaults.ts, 10, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 10, 23))
+f01<A>(a);
+>f01 : Symbol(f01, Decl(genericDefaults.ts, 19, 7))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f01c00 = f01();
->f01c00 : Symbol(f01c00, Decl(genericDefaults.ts, 11, 5))
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
+// function with a type paramter with a default
+declare function f02<T = A>(a?: T): T;
+>f02 : Symbol(f02, Decl(genericDefaults.ts, 28, 10))
+>T : Symbol(T, Decl(genericDefaults.ts, 31, 21))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 31, 28))
+>T : Symbol(T, Decl(genericDefaults.ts, 31, 21))
+>T : Symbol(T, Decl(genericDefaults.ts, 31, 21))
 
-const f01c01 = f01(1);
->f01c01 : Symbol(f01c01, Decl(genericDefaults.ts, 12, 5))
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
+// inference
+f02();
+>f02 : Symbol(f02, Decl(genericDefaults.ts, 28, 10))
 
-const f01c02 = f01(1, "a");
->f01c02 : Symbol(f01c02, Decl(genericDefaults.ts, 13, 5))
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
+f02(a);
+>f02 : Symbol(f02, Decl(genericDefaults.ts, 28, 10))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f01c03 = f01<number>();
->f01c03 : Symbol(f01c03, Decl(genericDefaults.ts, 14, 5))
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
+f02(b);
+>f02 : Symbol(f02, Decl(genericDefaults.ts, 28, 10))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
 
-const f01c04 = f01<number>(1);
->f01c04 : Symbol(f01c04, Decl(genericDefaults.ts, 15, 5))
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
+// no inference, fully supplied
+f02<A>();
+>f02 : Symbol(f02, Decl(genericDefaults.ts, 28, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
 
-const f01c05 = f01<number>(1, 2);
->f01c05 : Symbol(f01c05, Decl(genericDefaults.ts, 16, 5))
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
+f02<A>(a);
+>f02 : Symbol(f02, Decl(genericDefaults.ts, 28, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f01c06 = f01<number, string>();
->f01c06 : Symbol(f01c06, Decl(genericDefaults.ts, 17, 5))
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
+f02<B>();
+>f02 : Symbol(f02, Decl(genericDefaults.ts, 28, 10))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
 
-const f01c07 = f01<number, string>(1);
->f01c07 : Symbol(f01c07, Decl(genericDefaults.ts, 18, 5))
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
+f02<B>(b);
+>f02 : Symbol(f02, Decl(genericDefaults.ts, 28, 10))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
 
-const f01c08 = f01<number, string>(1, "a");
->f01c08 : Symbol(f01c08, Decl(genericDefaults.ts, 19, 5))
->f01 : Symbol(f01, Decl(genericDefaults.ts, 8, 32))
-
-declare function f02<T extends number, U = T>(a?: T, b?: U): [T, U];
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
->T : Symbol(T, Decl(genericDefaults.ts, 21, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 21, 38))
->T : Symbol(T, Decl(genericDefaults.ts, 21, 21))
->a : Symbol(a, Decl(genericDefaults.ts, 21, 46))
->T : Symbol(T, Decl(genericDefaults.ts, 21, 21))
->b : Symbol(b, Decl(genericDefaults.ts, 21, 52))
->U : Symbol(U, Decl(genericDefaults.ts, 21, 38))
->T : Symbol(T, Decl(genericDefaults.ts, 21, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 21, 38))
-
-const f02c00 = f02();
->f02c00 : Symbol(f02c00, Decl(genericDefaults.ts, 22, 5))
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
-
-const f02c01 = f02(1);
->f02c01 : Symbol(f02c01, Decl(genericDefaults.ts, 23, 5))
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
-
-const f02c02 = f02(1, "a");
->f02c02 : Symbol(f02c02, Decl(genericDefaults.ts, 24, 5))
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
-
-const f02c03 = f02<number>();
->f02c03 : Symbol(f02c03, Decl(genericDefaults.ts, 25, 5))
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
-
-const f02c04 = f02<number>(1);
->f02c04 : Symbol(f02c04, Decl(genericDefaults.ts, 26, 5))
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
-
-const f02c05 = f02<number>(1, 2);
->f02c05 : Symbol(f02c05, Decl(genericDefaults.ts, 27, 5))
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
-
-const f02c06 = f02<number, string>();
->f02c06 : Symbol(f02c06, Decl(genericDefaults.ts, 28, 5))
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
-
-const f02c07 = f02<number, string>(1);
->f02c07 : Symbol(f02c07, Decl(genericDefaults.ts, 29, 5))
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
-
-const f02c08 = f02<number, string>(1, "a");
->f02c08 : Symbol(f02c08, Decl(genericDefaults.ts, 30, 5))
->f02 : Symbol(f02, Decl(genericDefaults.ts, 19, 43))
-
-declare function f03<T extends number, U extends T = T>(a?: T, b?: U): [T, U];
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
->T : Symbol(T, Decl(genericDefaults.ts, 32, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 32, 38))
->T : Symbol(T, Decl(genericDefaults.ts, 32, 21))
->T : Symbol(T, Decl(genericDefaults.ts, 32, 21))
->a : Symbol(a, Decl(genericDefaults.ts, 32, 56))
->T : Symbol(T, Decl(genericDefaults.ts, 32, 21))
->b : Symbol(b, Decl(genericDefaults.ts, 32, 62))
->U : Symbol(U, Decl(genericDefaults.ts, 32, 38))
->T : Symbol(T, Decl(genericDefaults.ts, 32, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 32, 38))
-
-const f03c00 = f03();
->f03c00 : Symbol(f03c00, Decl(genericDefaults.ts, 33, 5))
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
-
-const f03c01 = f03(1);
->f03c01 : Symbol(f03c01, Decl(genericDefaults.ts, 34, 5))
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
-
-const f03c02 = f03(1, 1);
->f03c02 : Symbol(f03c02, Decl(genericDefaults.ts, 35, 5))
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
-
-const f03c03 = f03<number>();
->f03c03 : Symbol(f03c03, Decl(genericDefaults.ts, 36, 5))
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
-
-const f03c04 = f03<number>(1);
->f03c04 : Symbol(f03c04, Decl(genericDefaults.ts, 37, 5))
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
-
-const f03c05 = f03<number>(1, 2);
->f03c05 : Symbol(f03c05, Decl(genericDefaults.ts, 38, 5))
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
-
-const f03c06 = f03<number, number>();
->f03c06 : Symbol(f03c06, Decl(genericDefaults.ts, 39, 5))
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
-
-const f03c07 = f03<number, number>(1);
->f03c07 : Symbol(f03c07, Decl(genericDefaults.ts, 40, 5))
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
-
-const f03c08 = f03<number, number>(1, 2);
->f03c08 : Symbol(f03c08, Decl(genericDefaults.ts, 41, 5))
->f03 : Symbol(f03, Decl(genericDefaults.ts, 30, 43))
-
-declare function f04<T, U = T | { a: number }>(a?: T, b?: U): [T, U];
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+// function with a type parameter with a default that refers to itself
+declare function f03<T = T>(a?: T): T;
+>f03 : Symbol(f03, Decl(genericDefaults.ts, 40, 10))
 >T : Symbol(T, Decl(genericDefaults.ts, 43, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 43, 23))
 >T : Symbol(T, Decl(genericDefaults.ts, 43, 21))
->a : Symbol(a, Decl(genericDefaults.ts, 43, 33))
->a : Symbol(a, Decl(genericDefaults.ts, 43, 47))
+>a : Symbol(a, Decl(genericDefaults.ts, 43, 28))
 >T : Symbol(T, Decl(genericDefaults.ts, 43, 21))
->b : Symbol(b, Decl(genericDefaults.ts, 43, 53))
->U : Symbol(U, Decl(genericDefaults.ts, 43, 23))
 >T : Symbol(T, Decl(genericDefaults.ts, 43, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 43, 23))
 
-const f04c00 = f04();
->f04c00 : Symbol(f04c00, Decl(genericDefaults.ts, 44, 5))
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+// inference
+f03();
+>f03 : Symbol(f03, Decl(genericDefaults.ts, 40, 10))
 
-const f04c01 = f04(1);
->f04c01 : Symbol(f04c01, Decl(genericDefaults.ts, 45, 5))
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+f03(a);
+>f03 : Symbol(f03, Decl(genericDefaults.ts, 40, 10))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f04c02 = f04(1, 1);
->f04c02 : Symbol(f04c02, Decl(genericDefaults.ts, 46, 5))
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+f03(b);
+>f03 : Symbol(f03, Decl(genericDefaults.ts, 40, 10))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
 
-const f04c03 = f04<number>();
->f04c03 : Symbol(f04c03, Decl(genericDefaults.ts, 47, 5))
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+// no inference, fully supplied
+f03<A>();
+>f03 : Symbol(f03, Decl(genericDefaults.ts, 40, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
 
-const f04c04 = f04<number>(1);
->f04c04 : Symbol(f04c04, Decl(genericDefaults.ts, 48, 5))
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+f03<A>(a);
+>f03 : Symbol(f03, Decl(genericDefaults.ts, 40, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f04c05 = f04<number>(1, 2);
->f04c05 : Symbol(f04c05, Decl(genericDefaults.ts, 49, 5))
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+f03<B>();
+>f03 : Symbol(f03, Decl(genericDefaults.ts, 40, 10))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
 
-const f04c06 = f04<number, number>();
->f04c06 : Symbol(f04c06, Decl(genericDefaults.ts, 50, 5))
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+f03<B>(b);
+>f03 : Symbol(f03, Decl(genericDefaults.ts, 40, 10))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
 
-const f04c07 = f04<number, number>(1);
->f04c07 : Symbol(f04c07, Decl(genericDefaults.ts, 51, 5))
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+// function with a type paramter without a default and a type parameter with a default
+declare function f04<T, U = B>(a?: T, b?: U): [T, U];
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>T : Symbol(T, Decl(genericDefaults.ts, 55, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 55, 23))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 55, 31))
+>T : Symbol(T, Decl(genericDefaults.ts, 55, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 55, 37))
+>U : Symbol(U, Decl(genericDefaults.ts, 55, 23))
+>T : Symbol(T, Decl(genericDefaults.ts, 55, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 55, 23))
 
-const f04c08 = f04<number, number>(1, 2);
->f04c08 : Symbol(f04c08, Decl(genericDefaults.ts, 52, 5))
->f04 : Symbol(f04, Decl(genericDefaults.ts, 41, 41))
+// inference
+f04();
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
 
-declare function f05<T, U = T & { b: number }>(a?: T, b?: U): [T, U];
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
->T : Symbol(T, Decl(genericDefaults.ts, 54, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 54, 23))
->T : Symbol(T, Decl(genericDefaults.ts, 54, 21))
->b : Symbol(b, Decl(genericDefaults.ts, 54, 33))
->a : Symbol(a, Decl(genericDefaults.ts, 54, 47))
->T : Symbol(T, Decl(genericDefaults.ts, 54, 21))
->b : Symbol(b, Decl(genericDefaults.ts, 54, 53))
->U : Symbol(U, Decl(genericDefaults.ts, 54, 23))
->T : Symbol(T, Decl(genericDefaults.ts, 54, 21))
->U : Symbol(U, Decl(genericDefaults.ts, 54, 23))
+f04(a);
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f05c00 = f05();
->f05c00 : Symbol(f05c00, Decl(genericDefaults.ts, 55, 5))
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
+f04(a, b);
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
 
-const f05c01 = f05(1);
->f05c01 : Symbol(f05c01, Decl(genericDefaults.ts, 56, 5))
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
+f04(a, c);
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
 
-const f05c02 = f05(1, 1);
->f05c02 : Symbol(f05c02, Decl(genericDefaults.ts, 57, 5))
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
+// no inference, partially supplied
+f04<A>();
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
 
-const f05c03 = f05<number>();
->f05c03 : Symbol(f05c03, Decl(genericDefaults.ts, 58, 5))
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
+f04<A>(a);
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f05c04 = f05<number>(1);
->f05c04 : Symbol(f05c04, Decl(genericDefaults.ts, 59, 5))
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
+f04<A>(a, b);
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
 
-const f05c05 = f05<{ a: number }>({ a: 1 }, { a: 2, b: 3});
->f05c05 : Symbol(f05c05, Decl(genericDefaults.ts, 60, 5))
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
->a : Symbol(a, Decl(genericDefaults.ts, 60, 20))
->a : Symbol(a, Decl(genericDefaults.ts, 60, 35))
->a : Symbol(a, Decl(genericDefaults.ts, 60, 45))
->b : Symbol(b, Decl(genericDefaults.ts, 60, 51))
+// no inference, fully supplied
+f04<A, B>();
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
 
-const f05c06 = f05<number, number>();
->f05c06 : Symbol(f05c06, Decl(genericDefaults.ts, 61, 5))
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
+f04<A, B>(a);
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
 
-const f05c07 = f05<number, number>(1);
->f05c07 : Symbol(f05c07, Decl(genericDefaults.ts, 62, 5))
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
+f04<A, B>(a, b);
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
 
-const f05c08 = f05<number, number>(1, 2);
->f05c08 : Symbol(f05c08, Decl(genericDefaults.ts, 63, 5))
->f05 : Symbol(f05, Decl(genericDefaults.ts, 52, 41))
+f04<A, C>();
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+f04<A, C>(a);
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f04<A, C>(a, c);
+>f04 : Symbol(f04, Decl(genericDefaults.ts, 52, 10))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// function with a type parameter without a default and a type parameter with a default that refers to an earlier type parameter
+declare function f05<T, U = T>(a?: T, b?: U): [T, U];
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 74, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 74, 23))
+>T : Symbol(T, Decl(genericDefaults.ts, 74, 21))
+>a : Symbol(a, Decl(genericDefaults.ts, 74, 31))
+>T : Symbol(T, Decl(genericDefaults.ts, 74, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 74, 37))
+>U : Symbol(U, Decl(genericDefaults.ts, 74, 23))
+>T : Symbol(T, Decl(genericDefaults.ts, 74, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 74, 23))
+
+// inference
+f05();
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+
+f05(a);
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f05(a, a);
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f05(a, b);
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, partially supplied
+f05<A>();
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f05<A>(a);
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f05<A>(a, a);
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+// no inference, fully supplied
+f05<A, B>();
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f05<A, B>(a);
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f05<A, B>(a, b);
+>f05 : Symbol(f05, Decl(genericDefaults.ts, 71, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// function with a type parameter with a default that refers to an earlier type parameter with a default
+declare function f06<T = A, U = T>(a?: T, b?: U): [T, U];
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 90, 21))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>U : Symbol(U, Decl(genericDefaults.ts, 90, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 90, 21))
+>a : Symbol(a, Decl(genericDefaults.ts, 90, 35))
+>T : Symbol(T, Decl(genericDefaults.ts, 90, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 90, 41))
+>U : Symbol(U, Decl(genericDefaults.ts, 90, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 90, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 90, 27))
+
+// inference
+f06();
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+
+f06(a);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f06(a, a);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f06(a, b);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f06(b, a);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f06(b, b);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, partially supplied
+f06<A>();
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f06<A>(a);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f06<A>(a, a);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f06<B>();
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f06<B>(b);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f06<B>(b, b);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, fully supplied
+f06<A, B>();
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f06<A, B>(a);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f06<A, B>(a, b);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f06<B, C>();
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+f06<B, C>(b);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f06<B, C>(b, c);
+>f06 : Symbol(f06, Decl(genericDefaults.ts, 87, 16))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// function with a type parameter without a default and a type parameter with a default that refers to an earlier type parameter with a default
+declare function f07<T, U = B, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 114, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 114, 23))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>V : Symbol(V, Decl(genericDefaults.ts, 114, 30))
+>U : Symbol(U, Decl(genericDefaults.ts, 114, 23))
+>a : Symbol(a, Decl(genericDefaults.ts, 114, 38))
+>T : Symbol(T, Decl(genericDefaults.ts, 114, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 114, 44))
+>U : Symbol(U, Decl(genericDefaults.ts, 114, 23))
+>c : Symbol(c, Decl(genericDefaults.ts, 114, 51))
+>V : Symbol(V, Decl(genericDefaults.ts, 114, 30))
+>T : Symbol(T, Decl(genericDefaults.ts, 114, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 114, 23))
+>V : Symbol(V, Decl(genericDefaults.ts, 114, 30))
+
+// inference
+f07();
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+
+f07(a, b);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f07(a, c);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+f07(a, b, b);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f07(a, b, c);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+f07(a, c, b);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f07(a, c, c);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, partially supplied
+f07<A>();
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f07<A>(a);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f07<A>(a, b);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f07<A>(a, b, b);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f07<A, B>();
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f07<A, B>(a);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f07<A, B>(a, b);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f07<A, B>(a, b, b);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f07<A, C>();
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+f07<A, C>(a);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f07<A, C>(a, c);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+f07<A, C>(a, c, c);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, fully supplied
+f07<A, B, C>();
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+f07<A, B, C>(a);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f07<A, B, C>(a, b);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f07<A, B, C>(a, b, c);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+f07<A, C, A>();
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f07<A, C, A>(a);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f07<A, C, D>(a, c);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+f07<A, C, D>(a, c, d);
+>f07 : Symbol(f07, Decl(genericDefaults.ts, 111, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+>d : Symbol(d, Decl(genericDefaults.ts, 10, 13))
+
+// function with a type parameter with a default that refers to an earlier type parameter with a constraint
+declare function f08<T extends A, U = T>(a?: T, b?: U): [T, U];
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>T : Symbol(T, Decl(genericDefaults.ts, 147, 21))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>U : Symbol(U, Decl(genericDefaults.ts, 147, 33))
+>T : Symbol(T, Decl(genericDefaults.ts, 147, 21))
+>a : Symbol(a, Decl(genericDefaults.ts, 147, 41))
+>T : Symbol(T, Decl(genericDefaults.ts, 147, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 147, 47))
+>U : Symbol(U, Decl(genericDefaults.ts, 147, 33))
+>T : Symbol(T, Decl(genericDefaults.ts, 147, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 147, 33))
+
+// inference
+f08();
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+
+f08(a);
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f08(a, a);
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f08(a, b);
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, partially supplied
+f08<A>();
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f08<A>(a);
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f08<A>(a, a);
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+// no inference, fully supplied
+f08<A, B>();
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f08<A, B>(a);
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f08<A, B>(a, b);
+>f08 : Symbol(f08, Decl(genericDefaults.ts, 144, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// function with a type parameter with a constraint and a default that refers to an earlier type parameter
+declare function f09<T, U extends T = T>(a?: T, b?: U): [T, U];
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 163, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 163, 23))
+>T : Symbol(T, Decl(genericDefaults.ts, 163, 21))
+>T : Symbol(T, Decl(genericDefaults.ts, 163, 21))
+>a : Symbol(a, Decl(genericDefaults.ts, 163, 41))
+>T : Symbol(T, Decl(genericDefaults.ts, 163, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 163, 47))
+>U : Symbol(U, Decl(genericDefaults.ts, 163, 23))
+>T : Symbol(T, Decl(genericDefaults.ts, 163, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 163, 23))
+
+// inference
+f09();
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+
+f09(a);
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f09(a, a);
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f09(a, ab);
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+// no inference, partially supplied
+f09<A>();
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f09<A>(a);
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f09<A>(a, a);
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f09<A>(a, ab);
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+// no inference, fully supplied
+f09<A, AB>();
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>AB : Symbol(AB, Decl(genericDefaults.ts, 3, 26))
+
+f09<A, AB>(a);
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>AB : Symbol(AB, Decl(genericDefaults.ts, 3, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f09<A, AB>(a, ab);
+>f09 : Symbol(f09, Decl(genericDefaults.ts, 160, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>AB : Symbol(AB, Decl(genericDefaults.ts, 3, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+// function with a type parameter with a constraint and a default that refers to an earlier type parameter with a constraint
+declare function f10<T extends A, U extends T = T>(a?: T, b?: U): [T, U];
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>T : Symbol(T, Decl(genericDefaults.ts, 180, 21))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>U : Symbol(U, Decl(genericDefaults.ts, 180, 33))
+>T : Symbol(T, Decl(genericDefaults.ts, 180, 21))
+>T : Symbol(T, Decl(genericDefaults.ts, 180, 21))
+>a : Symbol(a, Decl(genericDefaults.ts, 180, 51))
+>T : Symbol(T, Decl(genericDefaults.ts, 180, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 180, 57))
+>U : Symbol(U, Decl(genericDefaults.ts, 180, 33))
+>T : Symbol(T, Decl(genericDefaults.ts, 180, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 180, 33))
+
+// inference
+f10();
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+
+f10(a);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f10(a, a);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f10(a, ab);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+// no inference, partially supplied
+f10<A>();
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f10<A>(a);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f10<A>(a, a);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f10<A>(a, ab);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+// no inference, fully supplied
+f10<A, A>();
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f10<A, A>(a);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f10<A, A>(a, a);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f10<A, A>(a, ab);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+f10<A, AB>();
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>AB : Symbol(AB, Decl(genericDefaults.ts, 3, 26))
+
+f10<A, AB>(a);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>AB : Symbol(AB, Decl(genericDefaults.ts, 3, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f10<A, AB>(a, ab);
+>f10 : Symbol(f10, Decl(genericDefaults.ts, 177, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>AB : Symbol(AB, Decl(genericDefaults.ts, 3, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+// function with a type parameter with a default that refers to an earier type parameter in a union
+declare function f11<T, U = T | B>(a?: T, b?: U): [T, U];
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>T : Symbol(T, Decl(genericDefaults.ts, 201, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 201, 23))
+>T : Symbol(T, Decl(genericDefaults.ts, 201, 21))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 201, 35))
+>T : Symbol(T, Decl(genericDefaults.ts, 201, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 201, 41))
+>U : Symbol(U, Decl(genericDefaults.ts, 201, 23))
+>T : Symbol(T, Decl(genericDefaults.ts, 201, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 201, 23))
+
+// inference
+f11();
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+
+f11(a);
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f11(a, a);
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f11(a, b);
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f11(a, c);
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, partially supplied
+f11<A>();
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f11<A>(a);
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f11<A>(a, a);
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f11<A>(a, b);
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, fully supplied
+f11<A, C>();
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+f11<A, C>(a);
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f11<A, C>(a, c);
+>f11 : Symbol(f11, Decl(genericDefaults.ts, 198, 18))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// function with a type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f12<T, U = T & B>(a?: T, b?: U): [T, U];
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 219, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 219, 23))
+>T : Symbol(T, Decl(genericDefaults.ts, 219, 21))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 219, 35))
+>T : Symbol(T, Decl(genericDefaults.ts, 219, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 219, 41))
+>U : Symbol(U, Decl(genericDefaults.ts, 219, 23))
+>T : Symbol(T, Decl(genericDefaults.ts, 219, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 219, 23))
+
+// inference
+f12();
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+
+f12(a);
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f12(a, a);
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f12(a, b);
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f12(a, c);
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, partially supplied
+f12<A>();
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f12<A>(a);
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f12<A>(a, ab);
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+// no inference, fully supplied
+f12<A, C>();
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+f12<A, C>(a);
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f12<A, C>(a, c);
+>f12 : Symbol(f12, Decl(genericDefaults.ts, 216, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// function with a type parameter with a default that refers to a later type parameter with a default
+declare function f13<T = U, U = B>(a?: T, b?: U): [T, U];
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 236, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 236, 27))
+>U : Symbol(U, Decl(genericDefaults.ts, 236, 27))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 236, 35))
+>T : Symbol(T, Decl(genericDefaults.ts, 236, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 236, 41))
+>U : Symbol(U, Decl(genericDefaults.ts, 236, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 236, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 236, 27))
+
+// inference
+f13();
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+
+f13(a);
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f13(a, b);
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f13(a, c);
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, partially supplied
+f13<A>();
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f13<A>(a);
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f13<A>(a, b);
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, fully supplied
+f13<A, C>();
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+f13<A, C>(a);
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f13<A, C>(a, c);
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+f13<A, C>(a, c);
+>f13 : Symbol(f13, Decl(genericDefaults.ts, 233, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default
+declare function f14<T, U = V, V = C>(a?: T, b?: U, c?: V): [T, U, V];
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 253, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 253, 23))
+>V : Symbol(V, Decl(genericDefaults.ts, 253, 30))
+>V : Symbol(V, Decl(genericDefaults.ts, 253, 30))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 253, 38))
+>T : Symbol(T, Decl(genericDefaults.ts, 253, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 253, 44))
+>U : Symbol(U, Decl(genericDefaults.ts, 253, 23))
+>c : Symbol(c, Decl(genericDefaults.ts, 253, 51))
+>V : Symbol(V, Decl(genericDefaults.ts, 253, 30))
+>T : Symbol(T, Decl(genericDefaults.ts, 253, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 253, 23))
+>V : Symbol(V, Decl(genericDefaults.ts, 253, 30))
+
+// inference
+f14();
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+
+f14(a);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f14(a, b);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f14(a, b, c);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+f14(a, b, d);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>d : Symbol(d, Decl(genericDefaults.ts, 10, 13))
+
+// no inference, partially supplied
+f14<A>();
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f14<A>(a);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f14<A>(a, b);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f14<A>(a, b, c);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+f14<A, B>();
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f14<A, B>(a);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f14<A, B>(a, b);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f14<A, B>(a, b, c);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference fully supplied
+f14<A, B, D>();
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+
+f14<A, B, D>(a);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f14<A, B, D>(a, b);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f14<A, B, D>(a, b, d);
+>f14 : Symbol(f14, Decl(genericDefaults.ts, 250, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>d : Symbol(d, Decl(genericDefaults.ts, 10, 13))
+
+// function with two type parameters with defaults that mutually refer to each other
+declare function f15<T = U, U = T>(a?: T, b?: U): [T, U];
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+>T : Symbol(T, Decl(genericDefaults.ts, 276, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 276, 27))
+>U : Symbol(U, Decl(genericDefaults.ts, 276, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 276, 21))
+>a : Symbol(a, Decl(genericDefaults.ts, 276, 35))
+>T : Symbol(T, Decl(genericDefaults.ts, 276, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 276, 41))
+>U : Symbol(U, Decl(genericDefaults.ts, 276, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 276, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 276, 27))
+
+// inference
+f15();
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+
+f15(a);
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f15(a, b);
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, partially supplied
+f15<A>();
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f15<A>(a);
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f15<A>(a, a);
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+// no inference, fully supplied
+f15<A, B>();
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f15<A, B>(a);
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f15<A, B>(a, b);
+>f15 : Symbol(f15, Decl(genericDefaults.ts, 273, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// function with a type parameter without a default and two type parameters with defaults that mutually refer to each other
+declare function f16<T, U = V, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 291, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 291, 23))
+>V : Symbol(V, Decl(genericDefaults.ts, 291, 30))
+>V : Symbol(V, Decl(genericDefaults.ts, 291, 30))
+>U : Symbol(U, Decl(genericDefaults.ts, 291, 23))
+>a : Symbol(a, Decl(genericDefaults.ts, 291, 38))
+>T : Symbol(T, Decl(genericDefaults.ts, 291, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 291, 44))
+>U : Symbol(U, Decl(genericDefaults.ts, 291, 23))
+>c : Symbol(c, Decl(genericDefaults.ts, 291, 51))
+>V : Symbol(V, Decl(genericDefaults.ts, 291, 30))
+>T : Symbol(T, Decl(genericDefaults.ts, 291, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 291, 23))
+>V : Symbol(V, Decl(genericDefaults.ts, 291, 30))
+
+// no inference
+f16();
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+
+f16(a);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f16(a, b);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f16(a, b, b);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, partially supplied
+f16<A>();
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f16<A>(a);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f16<A>(a, b);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f16<A>(a, b, b);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f16<A, B>();
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f16<A, B>(a);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f16<A, B>(a, b);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f16<A, B>(a, b, b);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, fully supplied
+f16<A, B, D>();
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+
+f16<A, B, D>(a);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f16<A, B, D>(a, b);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f16<A, B, D>(a, b, d);
+>f16 : Symbol(f16, Decl(genericDefaults.ts, 288, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>d : Symbol(d, Decl(genericDefaults.ts, 10, 13))
+
+// function with a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in a union
+declare function f17<T = U, U = T | B>(a?: T, b?: U): [T, U];
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>T : Symbol(T, Decl(genericDefaults.ts, 313, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 313, 27))
+>U : Symbol(U, Decl(genericDefaults.ts, 313, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 313, 21))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 313, 39))
+>T : Symbol(T, Decl(genericDefaults.ts, 313, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 313, 45))
+>U : Symbol(U, Decl(genericDefaults.ts, 313, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 313, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 313, 27))
+
+// inference
+f17();
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+
+f17(a);
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f17(a, a);
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f17(a, b);
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f17(a, c);
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, partially supplied
+f17<A>();
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f17<A>(a);
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f17<A>(a, a);
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f17<A>(a, b);
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+// no inference, fully supplied
+f17<A, C>();
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+f17<A, C>(a);
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f17<A, C>(a, c);
+>f17 : Symbol(f17, Decl(genericDefaults.ts, 310, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in a union
+declare function f18<T, U = V, V = U | C>(a?: T, b?: U, c?: V): [T, U, V];
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 331, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 331, 23))
+>V : Symbol(V, Decl(genericDefaults.ts, 331, 30))
+>V : Symbol(V, Decl(genericDefaults.ts, 331, 30))
+>U : Symbol(U, Decl(genericDefaults.ts, 331, 23))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 331, 42))
+>T : Symbol(T, Decl(genericDefaults.ts, 331, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 331, 48))
+>U : Symbol(U, Decl(genericDefaults.ts, 331, 23))
+>c : Symbol(c, Decl(genericDefaults.ts, 331, 55))
+>V : Symbol(V, Decl(genericDefaults.ts, 331, 30))
+>T : Symbol(T, Decl(genericDefaults.ts, 331, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 331, 23))
+>V : Symbol(V, Decl(genericDefaults.ts, 331, 30))
+
+// inference
+f18();
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+
+f18(a);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f18(a, b);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f18(a, b, b);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f18(a, b, c);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, partially supplied
+f18<A>();
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f18<A>(a);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f18<A>(a, b);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f18<A>(a, b, b);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f18<A>(a, b, c);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+f18<A, B>();
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f18<A, B>(a);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f18<A, B>(a, b);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f18<A, B>(a, b, b);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f18<A, B>(a, b, c);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, fully supplied
+f18<A, B, D>();
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+
+f18<A, B, D>(a);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f18<A, B, D>(a, b);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f18<A, B, D>(a, b, d);
+>f18 : Symbol(f18, Decl(genericDefaults.ts, 328, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>d : Symbol(d, Decl(genericDefaults.ts, 10, 13))
+
+// function with a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f19<T = U, U = T & B>(a?: T, b?: U): [T, U];
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>T : Symbol(T, Decl(genericDefaults.ts, 356, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 356, 27))
+>U : Symbol(U, Decl(genericDefaults.ts, 356, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 356, 21))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 356, 39))
+>T : Symbol(T, Decl(genericDefaults.ts, 356, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 356, 45))
+>U : Symbol(U, Decl(genericDefaults.ts, 356, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 356, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 356, 27))
+
+// inference
+f19();
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+
+f19(a);
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f19(a, a);
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f19(a, b);
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f19(a, ab);
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+f19(a, c);
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, partially supplied
+f19<A>();
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f19<A>(a);
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f19<A>(a, ab);
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>ab : Symbol(ab, Decl(genericDefaults.ts, 11, 13))
+
+// no inference, fully supplied
+f19<A, C>();
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+
+f19<A, C>(a);
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f19<A, C>(a, c);
+>f19 : Symbol(f19, Decl(genericDefaults.ts, 353, 22))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f20<T, U = V, V = U & C>(a?: T, b?: U, c?: V): [T, U, V];
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 374, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 374, 23))
+>V : Symbol(V, Decl(genericDefaults.ts, 374, 30))
+>V : Symbol(V, Decl(genericDefaults.ts, 374, 30))
+>U : Symbol(U, Decl(genericDefaults.ts, 374, 23))
+>C : Symbol(C, Decl(genericDefaults.ts, 1, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 374, 42))
+>T : Symbol(T, Decl(genericDefaults.ts, 374, 21))
+>b : Symbol(b, Decl(genericDefaults.ts, 374, 48))
+>U : Symbol(U, Decl(genericDefaults.ts, 374, 23))
+>c : Symbol(c, Decl(genericDefaults.ts, 374, 55))
+>V : Symbol(V, Decl(genericDefaults.ts, 374, 30))
+>T : Symbol(T, Decl(genericDefaults.ts, 374, 21))
+>U : Symbol(U, Decl(genericDefaults.ts, 374, 23))
+>V : Symbol(V, Decl(genericDefaults.ts, 374, 30))
+
+// inference
+f20();
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+
+f20(a);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f20(a, b);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f20(a, b, c);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>c : Symbol(c, Decl(genericDefaults.ts, 9, 13))
+
+// no inference, partially supplied
+f20<A>();
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+
+f20<A>(a);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f20<A>(a, b);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f20<A>(a, b, bc);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>bc : Symbol(bc, Decl(genericDefaults.ts, 12, 13))
+
+f20<A, B>();
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+
+f20<A, B>(a);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f20<A, B>(a, b);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f20<A, B>(a, b, bc);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>bc : Symbol(bc, Decl(genericDefaults.ts, 12, 13))
+
+// no inference, fully supplied
+f20<A, B, D>();
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+
+f20<A, B, D>(a);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+
+f20<A, B, D>(a, b);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+
+f20<A, B, D>(a, b, d);
+>f20 : Symbol(f20, Decl(genericDefaults.ts, 371, 16))
+>A : Symbol(A, Decl(genericDefaults.ts, 0, 0))
+>B : Symbol(B, Decl(genericDefaults.ts, 0, 26))
+>D : Symbol(D, Decl(genericDefaults.ts, 2, 26))
+>a : Symbol(a, Decl(genericDefaults.ts, 7, 13))
+>b : Symbol(b, Decl(genericDefaults.ts, 8, 13))
+>d : Symbol(d, Decl(genericDefaults.ts, 10, 13))
 
 interface i00<T = number> { a: T; }
->i00 : Symbol(i00, Decl(genericDefaults.ts, 63, 41))
->T : Symbol(T, Decl(genericDefaults.ts, 65, 14))
->a : Symbol(i00.a, Decl(genericDefaults.ts, 65, 27))
->T : Symbol(T, Decl(genericDefaults.ts, 65, 14))
+>i00 : Symbol(i00, Decl(genericDefaults.ts, 393, 22))
+>T : Symbol(T, Decl(genericDefaults.ts, 395, 14))
+>a : Symbol(i00.a, Decl(genericDefaults.ts, 395, 27))
+>T : Symbol(T, Decl(genericDefaults.ts, 395, 14))
 
 const i00c00 = (<i00>x).a;
->i00c00 : Symbol(i00c00, Decl(genericDefaults.ts, 66, 5))
->(<i00>x).a : Symbol(i00.a, Decl(genericDefaults.ts, 65, 27))
->i00 : Symbol(i00, Decl(genericDefaults.ts, 63, 41))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i00.a, Decl(genericDefaults.ts, 65, 27))
+>i00c00 : Symbol(i00c00, Decl(genericDefaults.ts, 396, 5))
+>(<i00>x).a : Symbol(i00.a, Decl(genericDefaults.ts, 395, 27))
+>i00 : Symbol(i00, Decl(genericDefaults.ts, 393, 22))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i00.a, Decl(genericDefaults.ts, 395, 27))
 
 const i00c01 = (<i00<number>>x).a;
->i00c01 : Symbol(i00c01, Decl(genericDefaults.ts, 67, 5))
->(<i00<number>>x).a : Symbol(i00.a, Decl(genericDefaults.ts, 65, 27))
->i00 : Symbol(i00, Decl(genericDefaults.ts, 63, 41))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i00.a, Decl(genericDefaults.ts, 65, 27))
+>i00c01 : Symbol(i00c01, Decl(genericDefaults.ts, 397, 5))
+>(<i00<number>>x).a : Symbol(i00.a, Decl(genericDefaults.ts, 395, 27))
+>i00 : Symbol(i00, Decl(genericDefaults.ts, 393, 22))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i00.a, Decl(genericDefaults.ts, 395, 27))
 
 interface i01<T, U = T> { a: [T, U]; }
->i01 : Symbol(i01, Decl(genericDefaults.ts, 67, 34))
->T : Symbol(T, Decl(genericDefaults.ts, 69, 14))
->U : Symbol(U, Decl(genericDefaults.ts, 69, 16))
->T : Symbol(T, Decl(genericDefaults.ts, 69, 14))
->a : Symbol(i01.a, Decl(genericDefaults.ts, 69, 25))
->T : Symbol(T, Decl(genericDefaults.ts, 69, 14))
->U : Symbol(U, Decl(genericDefaults.ts, 69, 16))
+>i01 : Symbol(i01, Decl(genericDefaults.ts, 397, 34))
+>T : Symbol(T, Decl(genericDefaults.ts, 399, 14))
+>U : Symbol(U, Decl(genericDefaults.ts, 399, 16))
+>T : Symbol(T, Decl(genericDefaults.ts, 399, 14))
+>a : Symbol(i01.a, Decl(genericDefaults.ts, 399, 25))
+>T : Symbol(T, Decl(genericDefaults.ts, 399, 14))
+>U : Symbol(U, Decl(genericDefaults.ts, 399, 16))
 
 const i01c00 = (<i01<number>>x).a;
->i01c00 : Symbol(i01c00, Decl(genericDefaults.ts, 70, 5))
->(<i01<number>>x).a : Symbol(i01.a, Decl(genericDefaults.ts, 69, 25))
->i01 : Symbol(i01, Decl(genericDefaults.ts, 67, 34))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i01.a, Decl(genericDefaults.ts, 69, 25))
+>i01c00 : Symbol(i01c00, Decl(genericDefaults.ts, 400, 5))
+>(<i01<number>>x).a : Symbol(i01.a, Decl(genericDefaults.ts, 399, 25))
+>i01 : Symbol(i01, Decl(genericDefaults.ts, 397, 34))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i01.a, Decl(genericDefaults.ts, 399, 25))
 
 const i01c01 = (<i01<number, string>>x).a;
->i01c01 : Symbol(i01c01, Decl(genericDefaults.ts, 71, 5))
->(<i01<number, string>>x).a : Symbol(i01.a, Decl(genericDefaults.ts, 69, 25))
->i01 : Symbol(i01, Decl(genericDefaults.ts, 67, 34))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i01.a, Decl(genericDefaults.ts, 69, 25))
+>i01c01 : Symbol(i01c01, Decl(genericDefaults.ts, 401, 5))
+>(<i01<number, string>>x).a : Symbol(i01.a, Decl(genericDefaults.ts, 399, 25))
+>i01 : Symbol(i01, Decl(genericDefaults.ts, 397, 34))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i01.a, Decl(genericDefaults.ts, 399, 25))
 
 interface i02<T extends number, U = T> { a: [T, U]; }
->i02 : Symbol(i02, Decl(genericDefaults.ts, 71, 42))
->T : Symbol(T, Decl(genericDefaults.ts, 73, 14))
->U : Symbol(U, Decl(genericDefaults.ts, 73, 31))
->T : Symbol(T, Decl(genericDefaults.ts, 73, 14))
->a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
->T : Symbol(T, Decl(genericDefaults.ts, 73, 14))
->U : Symbol(U, Decl(genericDefaults.ts, 73, 31))
+>i02 : Symbol(i02, Decl(genericDefaults.ts, 401, 42))
+>T : Symbol(T, Decl(genericDefaults.ts, 403, 14))
+>U : Symbol(U, Decl(genericDefaults.ts, 403, 31))
+>T : Symbol(T, Decl(genericDefaults.ts, 403, 14))
+>a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
+>T : Symbol(T, Decl(genericDefaults.ts, 403, 14))
+>U : Symbol(U, Decl(genericDefaults.ts, 403, 31))
 
 const i02c00 = (<i02<number>>x).a;
->i02c00 : Symbol(i02c00, Decl(genericDefaults.ts, 74, 5))
->(<i02<number>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
->i02 : Symbol(i02, Decl(genericDefaults.ts, 71, 42))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
+>i02c00 : Symbol(i02c00, Decl(genericDefaults.ts, 404, 5))
+>(<i02<number>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
+>i02 : Symbol(i02, Decl(genericDefaults.ts, 401, 42))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
 
 const i02c01 = (<i02<1>>x).a;
->i02c01 : Symbol(i02c01, Decl(genericDefaults.ts, 75, 5))
->(<i02<1>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
->i02 : Symbol(i02, Decl(genericDefaults.ts, 71, 42))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
+>i02c01 : Symbol(i02c01, Decl(genericDefaults.ts, 405, 5))
+>(<i02<1>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
+>i02 : Symbol(i02, Decl(genericDefaults.ts, 401, 42))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
 
 const i02c02 = (<i02<number, number>>x).a;
->i02c02 : Symbol(i02c02, Decl(genericDefaults.ts, 76, 5))
->(<i02<number, number>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
->i02 : Symbol(i02, Decl(genericDefaults.ts, 71, 42))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
+>i02c02 : Symbol(i02c02, Decl(genericDefaults.ts, 406, 5))
+>(<i02<number, number>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
+>i02 : Symbol(i02, Decl(genericDefaults.ts, 401, 42))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
 
 const i02c03 = (<i02<1, number>>x).a;
->i02c03 : Symbol(i02c03, Decl(genericDefaults.ts, 77, 5))
->(<i02<1, number>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
->i02 : Symbol(i02, Decl(genericDefaults.ts, 71, 42))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
+>i02c03 : Symbol(i02c03, Decl(genericDefaults.ts, 407, 5))
+>(<i02<1, number>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
+>i02 : Symbol(i02, Decl(genericDefaults.ts, 401, 42))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
 
 const i02c04 = (<i02<number, 1>>x).a;
->i02c04 : Symbol(i02c04, Decl(genericDefaults.ts, 78, 5))
->(<i02<number, 1>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
->i02 : Symbol(i02, Decl(genericDefaults.ts, 71, 42))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i02.a, Decl(genericDefaults.ts, 73, 40))
+>i02c04 : Symbol(i02c04, Decl(genericDefaults.ts, 408, 5))
+>(<i02<number, 1>>x).a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
+>i02 : Symbol(i02, Decl(genericDefaults.ts, 401, 42))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i02.a, Decl(genericDefaults.ts, 403, 40))
 
 interface i03<T extends number, U extends T = T> { a: [T, U]; }
->i03 : Symbol(i03, Decl(genericDefaults.ts, 78, 37))
->T : Symbol(T, Decl(genericDefaults.ts, 80, 14))
->U : Symbol(U, Decl(genericDefaults.ts, 80, 31))
->T : Symbol(T, Decl(genericDefaults.ts, 80, 14))
->T : Symbol(T, Decl(genericDefaults.ts, 80, 14))
->a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
->T : Symbol(T, Decl(genericDefaults.ts, 80, 14))
->U : Symbol(U, Decl(genericDefaults.ts, 80, 31))
+>i03 : Symbol(i03, Decl(genericDefaults.ts, 408, 37))
+>T : Symbol(T, Decl(genericDefaults.ts, 410, 14))
+>U : Symbol(U, Decl(genericDefaults.ts, 410, 31))
+>T : Symbol(T, Decl(genericDefaults.ts, 410, 14))
+>T : Symbol(T, Decl(genericDefaults.ts, 410, 14))
+>a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
+>T : Symbol(T, Decl(genericDefaults.ts, 410, 14))
+>U : Symbol(U, Decl(genericDefaults.ts, 410, 31))
 
 const i03c00 = (<i03<number>>x).a;
->i03c00 : Symbol(i03c00, Decl(genericDefaults.ts, 81, 5))
->(<i03<number>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
->i03 : Symbol(i03, Decl(genericDefaults.ts, 78, 37))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
+>i03c00 : Symbol(i03c00, Decl(genericDefaults.ts, 411, 5))
+>(<i03<number>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
+>i03 : Symbol(i03, Decl(genericDefaults.ts, 408, 37))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
 
 const i03c01 = (<i03<1>>x).a;
->i03c01 : Symbol(i03c01, Decl(genericDefaults.ts, 82, 5))
->(<i03<1>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
->i03 : Symbol(i03, Decl(genericDefaults.ts, 78, 37))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
+>i03c01 : Symbol(i03c01, Decl(genericDefaults.ts, 412, 5))
+>(<i03<1>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
+>i03 : Symbol(i03, Decl(genericDefaults.ts, 408, 37))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
 
 const i03c02 = (<i03<number, number>>x).a;
->i03c02 : Symbol(i03c02, Decl(genericDefaults.ts, 83, 5))
->(<i03<number, number>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
->i03 : Symbol(i03, Decl(genericDefaults.ts, 78, 37))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
+>i03c02 : Symbol(i03c02, Decl(genericDefaults.ts, 413, 5))
+>(<i03<number, number>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
+>i03 : Symbol(i03, Decl(genericDefaults.ts, 408, 37))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
 
 const i03c03 = (<i03<1, 1>>x).a;
->i03c03 : Symbol(i03c03, Decl(genericDefaults.ts, 84, 5))
->(<i03<1, 1>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
->i03 : Symbol(i03, Decl(genericDefaults.ts, 78, 37))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
+>i03c03 : Symbol(i03c03, Decl(genericDefaults.ts, 414, 5))
+>(<i03<1, 1>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
+>i03 : Symbol(i03, Decl(genericDefaults.ts, 408, 37))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
 
 const i03c04 = (<i03<number, 1>>x).a;
->i03c04 : Symbol(i03c04, Decl(genericDefaults.ts, 85, 5))
->(<i03<number, 1>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
->i03 : Symbol(i03, Decl(genericDefaults.ts, 78, 37))
->x : Symbol(x, Decl(genericDefaults.ts, 0, 13))
->a : Symbol(i03.a, Decl(genericDefaults.ts, 80, 50))
+>i03c04 : Symbol(i03c04, Decl(genericDefaults.ts, 415, 5))
+>(<i03<number, 1>>x).a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
+>i03 : Symbol(i03, Decl(genericDefaults.ts, 408, 37))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i03.a, Decl(genericDefaults.ts, 410, 50))
 
 interface i04 {}
->i04 : Symbol(i04, Decl(genericDefaults.ts, 85, 37), Decl(genericDefaults.ts, 87, 16), Decl(genericDefaults.ts, 88, 19), Decl(genericDefaults.ts, 89, 28))
+>i04 : Symbol(i04, Decl(genericDefaults.ts, 415, 37), Decl(genericDefaults.ts, 417, 16), Decl(genericDefaults.ts, 418, 19), Decl(genericDefaults.ts, 419, 28))
 
 interface i04<T> {}
->i04 : Symbol(i04, Decl(genericDefaults.ts, 85, 37), Decl(genericDefaults.ts, 87, 16), Decl(genericDefaults.ts, 88, 19), Decl(genericDefaults.ts, 89, 28))
->T : Symbol(T, Decl(genericDefaults.ts, 88, 14), Decl(genericDefaults.ts, 89, 14), Decl(genericDefaults.ts, 90, 14))
+>i04 : Symbol(i04, Decl(genericDefaults.ts, 415, 37), Decl(genericDefaults.ts, 417, 16), Decl(genericDefaults.ts, 418, 19), Decl(genericDefaults.ts, 419, 28))
+>T : Symbol(T, Decl(genericDefaults.ts, 418, 14), Decl(genericDefaults.ts, 419, 14), Decl(genericDefaults.ts, 420, 14))
 
 interface i04<T = number> {}
->i04 : Symbol(i04, Decl(genericDefaults.ts, 85, 37), Decl(genericDefaults.ts, 87, 16), Decl(genericDefaults.ts, 88, 19), Decl(genericDefaults.ts, 89, 28))
->T : Symbol(T, Decl(genericDefaults.ts, 88, 14), Decl(genericDefaults.ts, 89, 14), Decl(genericDefaults.ts, 90, 14))
+>i04 : Symbol(i04, Decl(genericDefaults.ts, 415, 37), Decl(genericDefaults.ts, 417, 16), Decl(genericDefaults.ts, 418, 19), Decl(genericDefaults.ts, 419, 28))
+>T : Symbol(T, Decl(genericDefaults.ts, 418, 14), Decl(genericDefaults.ts, 419, 14), Decl(genericDefaults.ts, 420, 14))
 
 interface i04<T = number, U = string> {}
->i04 : Symbol(i04, Decl(genericDefaults.ts, 85, 37), Decl(genericDefaults.ts, 87, 16), Decl(genericDefaults.ts, 88, 19), Decl(genericDefaults.ts, 89, 28))
->T : Symbol(T, Decl(genericDefaults.ts, 88, 14), Decl(genericDefaults.ts, 89, 14), Decl(genericDefaults.ts, 90, 14))
->U : Symbol(U, Decl(genericDefaults.ts, 90, 25))
+>i04 : Symbol(i04, Decl(genericDefaults.ts, 415, 37), Decl(genericDefaults.ts, 417, 16), Decl(genericDefaults.ts, 418, 19), Decl(genericDefaults.ts, 419, 28))
+>T : Symbol(T, Decl(genericDefaults.ts, 418, 14), Decl(genericDefaults.ts, 419, 14), Decl(genericDefaults.ts, 420, 14))
+>U : Symbol(U, Decl(genericDefaults.ts, 420, 25))
+
+interface i05<T = T> { a: T; }
+>i05 : Symbol(i05, Decl(genericDefaults.ts, 420, 40))
+>T : Symbol(T, Decl(genericDefaults.ts, 422, 14))
+>T : Symbol(T, Decl(genericDefaults.ts, 422, 14))
+>a : Symbol(i05.a, Decl(genericDefaults.ts, 422, 22))
+>T : Symbol(T, Decl(genericDefaults.ts, 422, 14))
+
+const i05c00 = (<i05>x).a;
+>i05c00 : Symbol(i05c00, Decl(genericDefaults.ts, 423, 5))
+>(<i05>x).a : Symbol(i05.a, Decl(genericDefaults.ts, 422, 22))
+>i05 : Symbol(i05, Decl(genericDefaults.ts, 420, 40))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i05.a, Decl(genericDefaults.ts, 422, 22))
+
+const i05c01 = (<i05<number>>x).a;
+>i05c01 : Symbol(i05c01, Decl(genericDefaults.ts, 424, 5))
+>(<i05<number>>x).a : Symbol(i05.a, Decl(genericDefaults.ts, 422, 22))
+>i05 : Symbol(i05, Decl(genericDefaults.ts, 420, 40))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i05.a, Decl(genericDefaults.ts, 422, 22))
+
+interface i06<T = U, U = T> { a: [T, U]; }
+>i06 : Symbol(i06, Decl(genericDefaults.ts, 424, 34))
+>T : Symbol(T, Decl(genericDefaults.ts, 426, 14))
+>U : Symbol(U, Decl(genericDefaults.ts, 426, 20))
+>U : Symbol(U, Decl(genericDefaults.ts, 426, 20))
+>T : Symbol(T, Decl(genericDefaults.ts, 426, 14))
+>a : Symbol(i06.a, Decl(genericDefaults.ts, 426, 29))
+>T : Symbol(T, Decl(genericDefaults.ts, 426, 14))
+>U : Symbol(U, Decl(genericDefaults.ts, 426, 20))
+
+const i06c00 = (<i06>x).a;
+>i06c00 : Symbol(i06c00, Decl(genericDefaults.ts, 427, 5))
+>(<i06>x).a : Symbol(i06.a, Decl(genericDefaults.ts, 426, 29))
+>i06 : Symbol(i06, Decl(genericDefaults.ts, 424, 34))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i06.a, Decl(genericDefaults.ts, 426, 29))
+
+const i06c01 = (<i06<number>>x).a;
+>i06c01 : Symbol(i06c01, Decl(genericDefaults.ts, 428, 5))
+>(<i06<number>>x).a : Symbol(i06.a, Decl(genericDefaults.ts, 426, 29))
+>i06 : Symbol(i06, Decl(genericDefaults.ts, 424, 34))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i06.a, Decl(genericDefaults.ts, 426, 29))
+
+const i06c02 = (<i06<number, string>>x).a;
+>i06c02 : Symbol(i06c02, Decl(genericDefaults.ts, 429, 5))
+>(<i06<number, string>>x).a : Symbol(i06.a, Decl(genericDefaults.ts, 426, 29))
+>i06 : Symbol(i06, Decl(genericDefaults.ts, 424, 34))
+>x : Symbol(x, Decl(genericDefaults.ts, 13, 13))
+>a : Symbol(i06.a, Decl(genericDefaults.ts, 426, 29))
 
 interface Base01<T> { a: T; }
->Base01 : Symbol(Base01, Decl(genericDefaults.ts, 90, 40), Decl(genericDefaults.ts, 95, 13))
->T : Symbol(T, Decl(genericDefaults.ts, 92, 17))
->a : Symbol(Base01.a, Decl(genericDefaults.ts, 92, 21))
->T : Symbol(T, Decl(genericDefaults.ts, 92, 17))
+>Base01 : Symbol(Base01, Decl(genericDefaults.ts, 429, 42), Decl(genericDefaults.ts, 434, 13))
+>T : Symbol(T, Decl(genericDefaults.ts, 431, 17))
+>a : Symbol(Base01.a, Decl(genericDefaults.ts, 431, 21))
+>T : Symbol(T, Decl(genericDefaults.ts, 431, 17))
 
 interface Base01Constructor { new <T = number>(a?: T): Base01<T>; }
->Base01Constructor : Symbol(Base01Constructor, Decl(genericDefaults.ts, 92, 29))
->T : Symbol(T, Decl(genericDefaults.ts, 93, 35))
->a : Symbol(a, Decl(genericDefaults.ts, 93, 47))
->T : Symbol(T, Decl(genericDefaults.ts, 93, 35))
->Base01 : Symbol(Base01, Decl(genericDefaults.ts, 90, 40), Decl(genericDefaults.ts, 95, 13))
->T : Symbol(T, Decl(genericDefaults.ts, 93, 35))
+>Base01Constructor : Symbol(Base01Constructor, Decl(genericDefaults.ts, 431, 29))
+>T : Symbol(T, Decl(genericDefaults.ts, 432, 35))
+>a : Symbol(a, Decl(genericDefaults.ts, 432, 47))
+>T : Symbol(T, Decl(genericDefaults.ts, 432, 35))
+>Base01 : Symbol(Base01, Decl(genericDefaults.ts, 429, 42), Decl(genericDefaults.ts, 434, 13))
+>T : Symbol(T, Decl(genericDefaults.ts, 432, 35))
 
 declare const Base01: Base01Constructor;
->Base01 : Symbol(Base01, Decl(genericDefaults.ts, 90, 40), Decl(genericDefaults.ts, 95, 13))
->Base01Constructor : Symbol(Base01Constructor, Decl(genericDefaults.ts, 92, 29))
+>Base01 : Symbol(Base01, Decl(genericDefaults.ts, 429, 42), Decl(genericDefaults.ts, 434, 13))
+>Base01Constructor : Symbol(Base01Constructor, Decl(genericDefaults.ts, 431, 29))
 
 const Base01c00 = new Base01();
->Base01c00 : Symbol(Base01c00, Decl(genericDefaults.ts, 96, 5))
->Base01 : Symbol(Base01, Decl(genericDefaults.ts, 90, 40), Decl(genericDefaults.ts, 95, 13))
+>Base01c00 : Symbol(Base01c00, Decl(genericDefaults.ts, 435, 5))
+>Base01 : Symbol(Base01, Decl(genericDefaults.ts, 429, 42), Decl(genericDefaults.ts, 434, 13))
 
 const Base01c01 = new Base01(1);
->Base01c01 : Symbol(Base01c01, Decl(genericDefaults.ts, 97, 5))
->Base01 : Symbol(Base01, Decl(genericDefaults.ts, 90, 40), Decl(genericDefaults.ts, 95, 13))
+>Base01c01 : Symbol(Base01c01, Decl(genericDefaults.ts, 436, 5))
+>Base01 : Symbol(Base01, Decl(genericDefaults.ts, 429, 42), Decl(genericDefaults.ts, 434, 13))
 
 const Base01c02 = new Base01<number>();
->Base01c02 : Symbol(Base01c02, Decl(genericDefaults.ts, 98, 5))
->Base01 : Symbol(Base01, Decl(genericDefaults.ts, 90, 40), Decl(genericDefaults.ts, 95, 13))
+>Base01c02 : Symbol(Base01c02, Decl(genericDefaults.ts, 437, 5))
+>Base01 : Symbol(Base01, Decl(genericDefaults.ts, 429, 42), Decl(genericDefaults.ts, 434, 13))
 
 const Base01c03 = new Base01<number>(1);
->Base01c03 : Symbol(Base01c03, Decl(genericDefaults.ts, 99, 5))
->Base01 : Symbol(Base01, Decl(genericDefaults.ts, 90, 40), Decl(genericDefaults.ts, 95, 13))
+>Base01c03 : Symbol(Base01c03, Decl(genericDefaults.ts, 438, 5))
+>Base01 : Symbol(Base01, Decl(genericDefaults.ts, 429, 42), Decl(genericDefaults.ts, 434, 13))
 
 declare class Derived01<T> extends Base01<T> { }
->Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 99, 40))
->T : Symbol(T, Decl(genericDefaults.ts, 101, 24))
->Base01 : Symbol(Base01, Decl(genericDefaults.ts, 90, 40), Decl(genericDefaults.ts, 95, 13))
->T : Symbol(T, Decl(genericDefaults.ts, 101, 24))
+>Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 438, 40))
+>T : Symbol(T, Decl(genericDefaults.ts, 440, 24))
+>Base01 : Symbol(Base01, Decl(genericDefaults.ts, 429, 42), Decl(genericDefaults.ts, 434, 13))
+>T : Symbol(T, Decl(genericDefaults.ts, 440, 24))
 
 const Derived01c00 = new Derived01();
->Derived01c00 : Symbol(Derived01c00, Decl(genericDefaults.ts, 102, 5))
->Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 99, 40))
+>Derived01c00 : Symbol(Derived01c00, Decl(genericDefaults.ts, 441, 5))
+>Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 438, 40))
 
 const Derived01c01 = new Derived01(1);
->Derived01c01 : Symbol(Derived01c01, Decl(genericDefaults.ts, 103, 5))
->Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 99, 40))
+>Derived01c01 : Symbol(Derived01c01, Decl(genericDefaults.ts, 442, 5))
+>Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 438, 40))
 
 const Derived01c02 = new Derived01<number>();
->Derived01c02 : Symbol(Derived01c02, Decl(genericDefaults.ts, 104, 5))
->Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 99, 40))
+>Derived01c02 : Symbol(Derived01c02, Decl(genericDefaults.ts, 443, 5))
+>Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 438, 40))
 
 const Derived01c03 = new Derived01<number>(1);
->Derived01c03 : Symbol(Derived01c03, Decl(genericDefaults.ts, 105, 5))
->Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 99, 40))
+>Derived01c03 : Symbol(Derived01c03, Decl(genericDefaults.ts, 444, 5))
+>Derived01 : Symbol(Derived01, Decl(genericDefaults.ts, 438, 40))
 
 declare class Derived02<T = string> extends Base01<T> { }
->Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 105, 46))
->T : Symbol(T, Decl(genericDefaults.ts, 107, 24))
->Base01 : Symbol(Base01, Decl(genericDefaults.ts, 90, 40), Decl(genericDefaults.ts, 95, 13))
->T : Symbol(T, Decl(genericDefaults.ts, 107, 24))
+>Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 444, 46))
+>T : Symbol(T, Decl(genericDefaults.ts, 446, 24))
+>Base01 : Symbol(Base01, Decl(genericDefaults.ts, 429, 42), Decl(genericDefaults.ts, 434, 13))
+>T : Symbol(T, Decl(genericDefaults.ts, 446, 24))
 
 const Derived02c00 = new Derived02();
->Derived02c00 : Symbol(Derived02c00, Decl(genericDefaults.ts, 108, 5))
->Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 105, 46))
+>Derived02c00 : Symbol(Derived02c00, Decl(genericDefaults.ts, 447, 5))
+>Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 444, 46))
 
 const Derived02c01 = new Derived02(1);
->Derived02c01 : Symbol(Derived02c01, Decl(genericDefaults.ts, 109, 5))
->Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 105, 46))
+>Derived02c01 : Symbol(Derived02c01, Decl(genericDefaults.ts, 448, 5))
+>Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 444, 46))
 
 const Derived02c02 = new Derived02<number>();
->Derived02c02 : Symbol(Derived02c02, Decl(genericDefaults.ts, 110, 5))
->Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 105, 46))
+>Derived02c02 : Symbol(Derived02c02, Decl(genericDefaults.ts, 449, 5))
+>Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 444, 46))
 
 const Derived02c03 = new Derived02<number>(1);
->Derived02c03 : Symbol(Derived02c03, Decl(genericDefaults.ts, 111, 5))
->Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 105, 46))
+>Derived02c03 : Symbol(Derived02c03, Decl(genericDefaults.ts, 450, 5))
+>Derived02 : Symbol(Derived02, Decl(genericDefaults.ts, 444, 46))
 
diff --git a/tests/baselines/reference/genericDefaults.types b/tests/baselines/reference/genericDefaults.types
index 4977d2d8896..c8e86553346 100644
--- a/tests/baselines/reference/genericDefaults.types
+++ b/tests/baselines/reference/genericDefaults.types
@@ -1,50 +1,298 @@
 === tests/cases/compiler/genericDefaults.ts ===
+interface A { a: number; }
+>A : A
+>a : number
+
+interface B { b: number; }
+>B : B
+>b : number
+
+interface C { c: number; }
+>C : C
+>c : number
+
+interface D { d: number; }
+>D : D
+>d : number
+
+interface AB { a: number; b: number; }
+>AB : AB
+>a : number
+>b : number
+
+interface BC { b: number; c: number; }
+>BC : BC
+>b : number
+>c : number
+
+declare const a: A;
+>a : A
+>A : A
+
+declare const b: B;
+>b : B
+>B : B
+
+declare const c: C;
+>c : C
+>C : C
+
+declare const d: D;
+>d : D
+>D : D
+
+declare const ab: AB;
+>ab : AB
+>AB : AB
+
+declare const bc: BC;
+>bc : BC
+>BC : BC
+
 declare const x: any;
 >x : any
 
-declare function f00<T = number>(a?: T): T;
->f00 : <T = number>(a?: T) => T
+// function without type parameters
+declare function f00(a?: A): A;
+>f00 : (a?: A) => A
+>a : A
+>A : A
+>A : A
+
+// no inference
+f00();
+>f00() : A
+>f00 : (a?: A) => A
+
+f00(a);
+>f00(a) : A
+>f00 : (a?: A) => A
+>a : A
+
+// function with a type parameter without a default
+declare function f01<T>(a?: T): T;
+>f01 : <T>(a?: T) => T
 >T : T
 >a : T
 >T : T
 >T : T
 
-const f00c00 = f00();
->f00c00 : number
->f00() : number
->f00 : <T = number>(a?: T) => T
+// inference
+f01();
+>f01() : {}
+>f01 : <T>(a?: T) => T
 
-const f00c01 = f00(1);
->f00c01 : 1
->f00(1) : 1
->f00 : <T = number>(a?: T) => T
->1 : 1
+f01(a);
+>f01(a) : A
+>f01 : <T>(a?: T) => T
+>a : A
 
-const f00c02 = f00("a");
->f00c02 : "a"
->f00("a") : "a"
->f00 : <T = number>(a?: T) => T
->"a" : "a"
+// no inference, fully supplied
+f01<A>();
+>f01<A>() : A
+>f01 : <T>(a?: T) => T
+>A : A
 
-const f00c03 = f00<number>();
->f00c03 : number
->f00<number>() : number
->f00 : <T = number>(a?: T) => T
+f01<A>(a);
+>f01<A>(a) : A
+>f01 : <T>(a?: T) => T
+>A : A
+>a : A
 
-const f00c04 = f00<number>(1);
->f00c04 : number
->f00<number>(1) : number
->f00 : <T = number>(a?: T) => T
->1 : 1
+// function with a type paramter with a default
+declare function f02<T = A>(a?: T): T;
+>f02 : <T = A>(a?: T) => T
+>T : T
+>A : A
+>a : T
+>T : T
+>T : T
 
-const f00c05 = f00<string>("a");
->f00c05 : string
->f00<string>("a") : string
->f00 : <T = number>(a?: T) => T
->"a" : "a"
+// inference
+f02();
+>f02() : A
+>f02 : <T = A>(a?: T) => T
 
-declare function f01<T, U = T>(a?: T, b?: U): [T, U];
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
+f02(a);
+>f02(a) : A
+>f02 : <T = A>(a?: T) => T
+>a : A
+
+f02(b);
+>f02(b) : B
+>f02 : <T = A>(a?: T) => T
+>b : B
+
+// no inference, fully supplied
+f02<A>();
+>f02<A>() : A
+>f02 : <T = A>(a?: T) => T
+>A : A
+
+f02<A>(a);
+>f02<A>(a) : A
+>f02 : <T = A>(a?: T) => T
+>A : A
+>a : A
+
+f02<B>();
+>f02<B>() : B
+>f02 : <T = A>(a?: T) => T
+>B : B
+
+f02<B>(b);
+>f02<B>(b) : B
+>f02 : <T = A>(a?: T) => T
+>B : B
+>b : B
+
+// function with a type parameter with a default that refers to itself
+declare function f03<T = T>(a?: T): T;
+>f03 : <T = T>(a?: T) => T
+>T : T
+>T : T
+>a : T
+>T : T
+>T : T
+
+// inference
+f03();
+>f03() : {}
+>f03 : <T = T>(a?: T) => T
+
+f03(a);
+>f03(a) : A
+>f03 : <T = T>(a?: T) => T
+>a : A
+
+f03(b);
+>f03(b) : B
+>f03 : <T = T>(a?: T) => T
+>b : B
+
+// no inference, fully supplied
+f03<A>();
+>f03<A>() : A
+>f03 : <T = T>(a?: T) => T
+>A : A
+
+f03<A>(a);
+>f03<A>(a) : A
+>f03 : <T = T>(a?: T) => T
+>A : A
+>a : A
+
+f03<B>();
+>f03<B>() : B
+>f03 : <T = T>(a?: T) => T
+>B : B
+
+f03<B>(b);
+>f03<B>(b) : B
+>f03 : <T = T>(a?: T) => T
+>B : B
+>b : B
+
+// function with a type paramter without a default and a type parameter with a default
+declare function f04<T, U = B>(a?: T, b?: U): [T, U];
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>T : T
+>U : U
+>B : B
+>a : T
+>T : T
+>b : U
+>U : U
+>T : T
+>U : U
+
+// inference
+f04();
+>f04() : [{}, B]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+
+f04(a);
+>f04(a) : [A, B]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>a : A
+
+f04(a, b);
+>f04(a, b) : [A, B]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
+
+f04(a, c);
+>f04(a, c) : [A, C]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>a : A
+>c : C
+
+// no inference, partially supplied
+f04<A>();
+>f04<A>() : [A, B]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+
+f04<A>(a);
+>f04<A>(a) : [A, B]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+
+f04<A>(a, b);
+>f04<A>(a, b) : [A, B]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>b : B
+
+// no inference, fully supplied
+f04<A, B>();
+>f04<A, B>() : [A, B]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+
+f04<A, B>(a);
+>f04<A, B>(a) : [A, B]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
+
+f04<A, B>(a, b);
+>f04<A, B>(a, b) : [A, B]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
+>b : B
+
+f04<A, C>();
+>f04<A, C>() : [A, C]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+
+f04<A, C>(a);
+>f04<A, C>(a) : [A, C]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+
+f04<A, C>(a, c);
+>f04<A, C>(a, c) : [A, C]
+>f04 : <T, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+>c : C
+
+// function with a type parameter without a default and a type parameter with a default that refers to an earlier type parameter
+declare function f05<T, U = T>(a?: T, b?: U): [T, U];
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
 >T : T
 >U : U
 >T : T
@@ -55,63 +303,74 @@ declare function f01<T, U = T>(a?: T, b?: U): [T, U];
 >T : T
 >U : U
 
-const f01c00 = f01();
->f01c00 : [{}, {}]
->f01() : [{}, {}]
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
+// inference
+f05();
+>f05() : [{}, {}]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
 
-const f01c01 = f01(1);
->f01c01 : [number, number]
->f01(1) : [number, number]
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
+f05(a);
+>f05(a) : [A, A]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
+>a : A
 
-const f01c02 = f01(1, "a");
->f01c02 : [number, string]
->f01(1, "a") : [number, string]
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
->"a" : "a"
+f05(a, a);
+>f05(a, a) : [A, A]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
+>a : A
+>a : A
 
-const f01c03 = f01<number>();
->f01c03 : [number, number]
->f01<number>() : [number, number]
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
+f05(a, b);
+>f05(a, b) : [A, B]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
 
-const f01c04 = f01<number>(1);
->f01c04 : [number, number]
->f01<number>(1) : [number, number]
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
+// no inference, partially supplied
+f05<A>();
+>f05<A>() : [A, A]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
+>A : A
 
-const f01c05 = f01<number>(1, 2);
->f01c05 : [number, number]
->f01<number>(1, 2) : [number, number]
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
->2 : 2
+f05<A>(a);
+>f05<A>(a) : [A, A]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
 
-const f01c06 = f01<number, string>();
->f01c06 : [number, string]
->f01<number, string>() : [number, string]
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
+f05<A>(a, a);
+>f05<A>(a, a) : [A, A]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>a : A
 
-const f01c07 = f01<number, string>(1);
->f01c07 : [number, string]
->f01<number, string>(1) : [number, string]
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
+// no inference, fully supplied
+f05<A, B>();
+>f05<A, B>() : [A, B]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
 
-const f01c08 = f01<number, string>(1, "a");
->f01c08 : [number, string]
->f01<number, string>(1, "a") : [number, string]
->f01 : <T, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
->"a" : "a"
+f05<A, B>(a);
+>f05<A, B>(a) : [A, B]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
 
-declare function f02<T extends number, U = T>(a?: T, b?: U): [T, U];
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
+f05<A, B>(a, b);
+>f05<A, B>(a, b) : [A, B]
+>f05 : <T, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
+>b : B
+
+// function with a type parameter with a default that refers to an earlier type parameter with a default
+declare function f06<T = A, U = T>(a?: T, b?: U): [T, U];
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
 >T : T
+>A : A
 >U : U
 >T : T
 >a : T
@@ -121,62 +380,419 @@ declare function f02<T extends number, U = T>(a?: T, b?: U): [T, U];
 >T : T
 >U : U
 
-const f02c00 = f02();
->f02c00 : [number, number]
->f02() : [number, number]
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
+// inference
+f06();
+>f06() : [A, A]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
 
-const f02c01 = f02(1);
->f02c01 : [1, 1]
->f02(1) : [1, 1]
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
+f06(a);
+>f06(a) : [A, A]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>a : A
 
-const f02c02 = f02(1, "a");
->f02c02 : [1, string]
->f02(1, "a") : [1, string]
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
->"a" : "a"
+f06(a, a);
+>f06(a, a) : [A, A]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>a : A
+>a : A
 
-const f02c03 = f02<number>();
->f02c03 : [number, number]
->f02<number>() : [number, number]
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
+f06(a, b);
+>f06(a, b) : [A, B]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
 
-const f02c04 = f02<number>(1);
->f02c04 : [number, number]
->f02<number>(1) : [number, number]
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
+f06(b, a);
+>f06(b, a) : [B, A]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>b : B
+>a : A
 
-const f02c05 = f02<number>(1, 2);
->f02c05 : [number, number]
->f02<number>(1, 2) : [number, number]
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
->2 : 2
+f06(b, b);
+>f06(b, b) : [B, B]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>b : B
+>b : B
 
-const f02c06 = f02<number, string>();
->f02c06 : [number, string]
->f02<number, string>() : [number, string]
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
+// no inference, partially supplied
+f06<A>();
+>f06<A>() : [A, A]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
 
-const f02c07 = f02<number, string>(1);
->f02c07 : [number, string]
->f02<number, string>(1) : [number, string]
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
+f06<A>(a);
+>f06<A>(a) : [A, A]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
 
-const f02c08 = f02<number, string>(1, "a");
->f02c08 : [number, string]
->f02<number, string>(1, "a") : [number, string]
->f02 : <T extends number, U = T>(a?: T, b?: U) => [T, U]
->1 : 1
->"a" : "a"
+f06<A>(a, a);
+>f06<A>(a, a) : [A, A]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>a : A
 
-declare function f03<T extends number, U extends T = T>(a?: T, b?: U): [T, U];
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
+f06<B>();
+>f06<B>() : [B, B]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>B : B
+
+f06<B>(b);
+>f06<B>(b) : [B, B]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>B : B
+>b : B
+
+f06<B>(b, b);
+>f06<B>(b, b) : [B, B]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>B : B
+>b : B
+>b : B
+
+// no inference, fully supplied
+f06<A, B>();
+>f06<A, B>() : [A, B]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+
+f06<A, B>(a);
+>f06<A, B>(a) : [A, B]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
+
+f06<A, B>(a, b);
+>f06<A, B>(a, b) : [A, B]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
+>b : B
+
+f06<B, C>();
+>f06<B, C>() : [B, C]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>B : B
+>C : C
+
+f06<B, C>(b);
+>f06<B, C>(b) : [B, C]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>B : B
+>C : C
+>b : B
+
+f06<B, C>(b, c);
+>f06<B, C>(b, c) : [B, C]
+>f06 : <T = A, U = T>(a?: T, b?: U) => [T, U]
+>B : B
+>C : C
+>b : B
+>c : C
+
+// function with a type parameter without a default and a type parameter with a default that refers to an earlier type parameter with a default
+declare function f07<T, U = B, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>T : T
+>U : U
+>B : B
+>V : V
+>U : U
+>a : T
+>T : T
+>b : U
+>U : U
+>c : V
+>V : V
+>T : T
+>U : U
+>V : V
+
+// inference
+f07();
+>f07() : [{}, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+
+f07(a, b);
+>f07(a, b) : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+
+f07(a, c);
+>f07(a, c) : [A, C, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>c : C
+
+f07(a, b, b);
+>f07(a, b, b) : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+>b : B
+
+f07(a, b, c);
+>f07(a, b, c) : [A, B, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+>c : C
+
+f07(a, c, b);
+>f07(a, c, b) : [A, C, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>c : C
+>b : B
+
+f07(a, c, c);
+>f07(a, c, c) : [A, C, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>c : C
+>c : C
+
+// no inference, partially supplied
+f07<A>();
+>f07<A>() : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+
+f07<A>(a);
+>f07<A>(a) : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+
+f07<A>(a, b);
+>f07<A>(a, b) : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+
+f07<A>(a, b, b);
+>f07<A>(a, b, b) : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+>b : B
+
+f07<A, B>();
+>f07<A, B>() : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+
+f07<A, B>(a);
+>f07<A, B>(a) : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+
+f07<A, B>(a, b);
+>f07<A, B>(a, b) : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+
+f07<A, B>(a, b, b);
+>f07<A, B>(a, b, b) : [A, B, B]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+>b : B
+
+f07<A, C>();
+>f07<A, C>() : [A, C, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>C : C
+
+f07<A, C>(a);
+>f07<A, C>(a) : [A, C, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>C : C
+>a : A
+
+f07<A, C>(a, c);
+>f07<A, C>(a, c) : [A, C, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>C : C
+>a : A
+>c : C
+
+f07<A, C>(a, c, c);
+>f07<A, C>(a, c, c) : [A, C, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>C : C
+>a : A
+>c : C
+>c : C
+
+// no inference, fully supplied
+f07<A, B, C>();
+>f07<A, B, C>() : [A, B, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>C : C
+
+f07<A, B, C>(a);
+>f07<A, B, C>(a) : [A, B, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>C : C
+>a : A
+
+f07<A, B, C>(a, b);
+>f07<A, B, C>(a, b) : [A, B, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>C : C
+>a : A
+>b : B
+
+f07<A, B, C>(a, b, c);
+>f07<A, B, C>(a, b, c) : [A, B, C]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>C : C
+>a : A
+>b : B
+>c : C
+
+f07<A, C, A>();
+>f07<A, C, A>() : [A, C, A]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>C : C
+>A : A
+
+f07<A, C, A>(a);
+>f07<A, C, A>(a) : [A, C, A]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>C : C
+>A : A
+>a : A
+
+f07<A, C, D>(a, c);
+>f07<A, C, D>(a, c) : [A, C, D]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>C : C
+>D : D
+>a : A
+>c : C
+
+f07<A, C, D>(a, c, d);
+>f07<A, C, D>(a, c, d) : [A, C, D]
+>f07 : <T, U = B, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>C : C
+>D : D
+>a : A
+>c : C
+>d : D
+
+// function with a type parameter with a default that refers to an earlier type parameter with a constraint
+declare function f08<T extends A, U = T>(a?: T, b?: U): [T, U];
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>T : T
+>A : A
+>U : U
+>T : T
+>a : T
+>T : T
+>b : U
+>U : U
+>T : T
+>U : U
+
+// inference
+f08();
+>f08() : [A, A]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+
+f08(a);
+>f08(a) : [A, A]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>a : A
+
+f08(a, a);
+>f08(a, a) : [A, A]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>a : A
+>a : A
+
+f08(a, b);
+>f08(a, b) : [A, B]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
+
+// no inference, partially supplied
+f08<A>();
+>f08<A>() : [A, A]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+
+f08<A>(a);
+>f08<A>(a) : [A, A]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+
+f08<A>(a, a);
+>f08<A>(a, a) : [A, A]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>a : A
+
+// no inference, fully supplied
+f08<A, B>();
+>f08<A, B>() : [A, B]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+
+f08<A, B>(a);
+>f08<A, B>(a) : [A, B]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
+
+f08<A, B>(a, b);
+>f08<A, B>(a, b) : [A, B]
+>f08 : <T extends A, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
+>b : B
+
+// function with a type parameter with a constraint and a default that refers to an earlier type parameter
+declare function f09<T, U extends T = T>(a?: T, b?: U): [T, U];
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
 >T : T
 >U : U
 >T : T
@@ -188,66 +804,84 @@ declare function f03<T extends number, U extends T = T>(a?: T, b?: U): [T, U];
 >T : T
 >U : U
 
-const f03c00 = f03();
->f03c00 : [number, number]
->f03() : [number, number]
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
+// inference
+f09();
+>f09() : [{}, {}]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
 
-const f03c01 = f03(1);
->f03c01 : [1, 1]
->f03(1) : [1, 1]
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
->1 : 1
+f09(a);
+>f09(a) : [A, A]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>a : A
 
-const f03c02 = f03(1, 1);
->f03c02 : [1, 1]
->f03(1, 1) : [1, 1]
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
->1 : 1
->1 : 1
+f09(a, a);
+>f09(a, a) : [A, A]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>a : A
+>a : A
 
-const f03c03 = f03<number>();
->f03c03 : [number, number]
->f03<number>() : [number, number]
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
+f09(a, ab);
+>f09(a, ab) : [A, AB]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>a : A
+>ab : AB
 
-const f03c04 = f03<number>(1);
->f03c04 : [number, number]
->f03<number>(1) : [number, number]
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
->1 : 1
+// no inference, partially supplied
+f09<A>();
+>f09<A>() : [A, A]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
 
-const f03c05 = f03<number>(1, 2);
->f03c05 : [number, number]
->f03<number>(1, 2) : [number, number]
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
->1 : 1
->2 : 2
+f09<A>(a);
+>f09<A>(a) : [A, A]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
 
-const f03c06 = f03<number, number>();
->f03c06 : [number, number]
->f03<number, number>() : [number, number]
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
+f09<A>(a, a);
+>f09<A>(a, a) : [A, A]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>a : A
 
-const f03c07 = f03<number, number>(1);
->f03c07 : [number, number]
->f03<number, number>(1) : [number, number]
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
->1 : 1
+f09<A>(a, ab);
+>f09<A>(a, ab) : [A, A]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>ab : AB
 
-const f03c08 = f03<number, number>(1, 2);
->f03c08 : [number, number]
->f03<number, number>(1, 2) : [number, number]
->f03 : <T extends number, U extends T = T>(a?: T, b?: U) => [T, U]
->1 : 1
->2 : 2
+// no inference, fully supplied
+f09<A, AB>();
+>f09<A, AB>() : [A, AB]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>AB : AB
 
-declare function f04<T, U = T | { a: number }>(a?: T, b?: U): [T, U];
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
+f09<A, AB>(a);
+>f09<A, AB>(a) : [A, AB]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>AB : AB
+>a : A
+
+f09<A, AB>(a, ab);
+>f09<A, AB>(a, ab) : [A, AB]
+>f09 : <T, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>AB : AB
+>a : A
+>ab : AB
+
+// function with a type parameter with a constraint and a default that refers to an earlier type parameter with a constraint
+declare function f10<T extends A, U extends T = T>(a?: T, b?: U): [T, U];
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
 >T : T
+>A : A
 >U : U
 >T : T
->a : number
+>T : T
 >a : T
 >T : T
 >b : U
@@ -255,66 +889,112 @@ declare function f04<T, U = T | { a: number }>(a?: T, b?: U): [T, U];
 >T : T
 >U : U
 
-const f04c00 = f04();
->f04c00 : [{}, {} | { a: number; }]
->f04() : [{}, {} | { a: number; }]
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
+// inference
+f10();
+>f10() : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
 
-const f04c01 = f04(1);
->f04c01 : [number, number | { a: number; }]
->f04(1) : [number, number | { a: number; }]
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
+f10(a);
+>f10(a) : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>a : A
 
-const f04c02 = f04(1, 1);
->f04c02 : [number, number]
->f04(1, 1) : [number, number]
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
->1 : 1
+f10(a, a);
+>f10(a, a) : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>a : A
+>a : A
 
-const f04c03 = f04<number>();
->f04c03 : [number, number | { a: number; }]
->f04<number>() : [number, number | { a: number; }]
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
+f10(a, ab);
+>f10(a, ab) : [A, AB]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>a : A
+>ab : AB
 
-const f04c04 = f04<number>(1);
->f04c04 : [number, number | { a: number; }]
->f04<number>(1) : [number, number | { a: number; }]
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
+// no inference, partially supplied
+f10<A>();
+>f10<A>() : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
 
-const f04c05 = f04<number>(1, 2);
->f04c05 : [number, number | { a: number; }]
->f04<number>(1, 2) : [number, number | { a: number; }]
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
->2 : 2
+f10<A>(a);
+>f10<A>(a) : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
 
-const f04c06 = f04<number, number>();
->f04c06 : [number, number]
->f04<number, number>() : [number, number]
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
+f10<A>(a, a);
+>f10<A>(a, a) : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>a : A
 
-const f04c07 = f04<number, number>(1);
->f04c07 : [number, number]
->f04<number, number>(1) : [number, number]
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
+f10<A>(a, ab);
+>f10<A>(a, ab) : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>ab : AB
 
-const f04c08 = f04<number, number>(1, 2);
->f04c08 : [number, number]
->f04<number, number>(1, 2) : [number, number]
->f04 : <T, U = T | { a: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
->2 : 2
+// no inference, fully supplied
+f10<A, A>();
+>f10<A, A>() : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>A : A
 
-declare function f05<T, U = T & { b: number }>(a?: T, b?: U): [T, U];
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
+f10<A, A>(a);
+>f10<A, A>(a) : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>A : A
+>a : A
+
+f10<A, A>(a, a);
+>f10<A, A>(a, a) : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>A : A
+>a : A
+>a : A
+
+f10<A, A>(a, ab);
+>f10<A, A>(a, ab) : [A, A]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>A : A
+>a : A
+>ab : AB
+
+f10<A, AB>();
+>f10<A, AB>() : [A, AB]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>AB : AB
+
+f10<A, AB>(a);
+>f10<A, AB>(a) : [A, AB]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>AB : AB
+>a : A
+
+f10<A, AB>(a, ab);
+>f10<A, AB>(a, ab) : [A, AB]
+>f10 : <T extends A, U extends T = T>(a?: T, b?: U) => [T, U]
+>A : A
+>AB : AB
+>a : A
+>ab : AB
+
+// function with a type parameter with a default that refers to an earier type parameter in a union
+declare function f11<T, U = T | B>(a?: T, b?: U): [T, U];
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
 >T : T
 >U : U
 >T : T
->b : number
+>B : B
 >a : T
 >T : T
 >b : U
@@ -322,66 +1002,1066 @@ declare function f05<T, U = T & { b: number }>(a?: T, b?: U): [T, U];
 >T : T
 >U : U
 
-const f05c00 = f05();
->f05c00 : [{}, {} & { b: number; }]
->f05() : [{}, {} & { b: number; }]
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
+// inference
+f11();
+>f11() : [{}, {} | B]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
 
-const f05c01 = f05(1);
->f05c01 : [number, number & { b: number; }]
->f05(1) : [number, number & { b: number; }]
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
+f11(a);
+>f11(a) : [A, A | B]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>a : A
 
-const f05c02 = f05(1, 1);
->f05c02 : [number, number]
->f05(1, 1) : [number, number]
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
->1 : 1
+f11(a, a);
+>f11(a, a) : [A, A]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>a : A
+>a : A
 
-const f05c03 = f05<number>();
->f05c03 : [number, number & { b: number; }]
->f05<number>() : [number, number & { b: number; }]
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
+f11(a, b);
+>f11(a, b) : [A, B]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
 
-const f05c04 = f05<number>(1);
->f05c04 : [number, number & { b: number; }]
->f05<number>(1) : [number, number & { b: number; }]
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
+f11(a, c);
+>f11(a, c) : [A, C]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>a : A
+>c : C
 
-const f05c05 = f05<{ a: number }>({ a: 1 }, { a: 2, b: 3});
->f05c05 : [{ a: number; }, { a: number; } & { b: number; }]
->f05<{ a: number }>({ a: 1 }, { a: 2, b: 3}) : [{ a: number; }, { a: number; } & { b: number; }]
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
->a : number
->{ a: 1 } : { a: number; }
->a : number
->1 : 1
->{ a: 2, b: 3} : { a: number; b: number; }
->a : number
->2 : 2
->b : number
->3 : 3
+// no inference, partially supplied
+f11<A>();
+>f11<A>() : [A, A | B]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
 
-const f05c06 = f05<number, number>();
->f05c06 : [number, number]
->f05<number, number>() : [number, number]
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
+f11<A>(a);
+>f11<A>(a) : [A, A | B]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
 
-const f05c07 = f05<number, number>(1);
->f05c07 : [number, number]
->f05<number, number>(1) : [number, number]
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
+f11<A>(a, a);
+>f11<A>(a, a) : [A, A | B]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>a : A
 
-const f05c08 = f05<number, number>(1, 2);
->f05c08 : [number, number]
->f05<number, number>(1, 2) : [number, number]
->f05 : <T, U = T & { b: number; }>(a?: T, b?: U) => [T, U]
->1 : 1
->2 : 2
+f11<A>(a, b);
+>f11<A>(a, b) : [A, A | B]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>b : B
+
+// no inference, fully supplied
+f11<A, C>();
+>f11<A, C>() : [A, C]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+
+f11<A, C>(a);
+>f11<A, C>(a) : [A, C]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+
+f11<A, C>(a, c);
+>f11<A, C>(a, c) : [A, C]
+>f11 : <T, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+>c : C
+
+// function with a type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f12<T, U = T & B>(a?: T, b?: U): [T, U];
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>T : T
+>U : U
+>T : T
+>B : B
+>a : T
+>T : T
+>b : U
+>U : U
+>T : T
+>U : U
+
+// inference
+f12();
+>f12() : [{}, {} & B]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+
+f12(a);
+>f12(a) : [A, A & B]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>a : A
+
+f12(a, a);
+>f12(a, a) : [A, A]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>a : A
+>a : A
+
+f12(a, b);
+>f12(a, b) : [A, B]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
+
+f12(a, c);
+>f12(a, c) : [A, C]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>a : A
+>c : C
+
+// no inference, partially supplied
+f12<A>();
+>f12<A>() : [A, A & B]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+
+f12<A>(a);
+>f12<A>(a) : [A, A & B]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+
+f12<A>(a, ab);
+>f12<A>(a, ab) : [A, A & B]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>ab : AB
+
+// no inference, fully supplied
+f12<A, C>();
+>f12<A, C>() : [A, C]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+
+f12<A, C>(a);
+>f12<A, C>(a) : [A, C]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+
+f12<A, C>(a, c);
+>f12<A, C>(a, c) : [A, C]
+>f12 : <T, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+>c : C
+
+// function with a type parameter with a default that refers to a later type parameter with a default
+declare function f13<T = U, U = B>(a?: T, b?: U): [T, U];
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>T : T
+>U : U
+>U : U
+>B : B
+>a : T
+>T : T
+>b : U
+>U : U
+>T : T
+>U : U
+
+// inference
+f13();
+>f13() : [{}, B]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+
+f13(a);
+>f13(a) : [A, B]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>a : A
+
+f13(a, b);
+>f13(a, b) : [A, B]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
+
+f13(a, c);
+>f13(a, c) : [A, C]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>a : A
+>c : C
+
+// no inference, partially supplied
+f13<A>();
+>f13<A>() : [A, B]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+
+f13<A>(a);
+>f13<A>(a) : [A, B]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+
+f13<A>(a, b);
+>f13<A>(a, b) : [A, B]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>b : B
+
+// no inference, fully supplied
+f13<A, C>();
+>f13<A, C>() : [A, C]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+
+f13<A, C>(a);
+>f13<A, C>(a) : [A, C]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+
+f13<A, C>(a, c);
+>f13<A, C>(a, c) : [A, C]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+>c : C
+
+f13<A, C>(a, c);
+>f13<A, C>(a, c) : [A, C]
+>f13 : <T = U, U = B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+>c : C
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default
+declare function f14<T, U = V, V = C>(a?: T, b?: U, c?: V): [T, U, V];
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>T : T
+>U : U
+>V : V
+>V : V
+>C : C
+>a : T
+>T : T
+>b : U
+>U : U
+>c : V
+>V : V
+>T : T
+>U : U
+>V : V
+
+// inference
+f14();
+>f14() : [{}, {}, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+
+f14(a);
+>f14(a) : [A, {}, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+
+f14(a, b);
+>f14(a, b) : [A, B, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+
+f14(a, b, c);
+>f14(a, b, c) : [A, B, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+>c : C
+
+f14(a, b, d);
+>f14(a, b, d) : [A, B, D]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+>d : D
+
+// no inference, partially supplied
+f14<A>();
+>f14<A>() : [A, {}, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+
+f14<A>(a);
+>f14<A>(a) : [A, {}, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+
+f14<A>(a, b);
+>f14<A>(a, b) : [A, {}, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+
+f14<A>(a, b, c);
+>f14<A>(a, b, c) : [A, {}, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+>c : C
+
+f14<A, B>();
+>f14<A, B>() : [A, B, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+
+f14<A, B>(a);
+>f14<A, B>(a) : [A, B, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+
+f14<A, B>(a, b);
+>f14<A, B>(a, b) : [A, B, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+
+f14<A, B>(a, b, c);
+>f14<A, B>(a, b, c) : [A, B, C]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+>c : C
+
+// no inference fully supplied
+f14<A, B, D>();
+>f14<A, B, D>() : [A, B, D]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+
+f14<A, B, D>(a);
+>f14<A, B, D>(a) : [A, B, D]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+
+f14<A, B, D>(a, b);
+>f14<A, B, D>(a, b) : [A, B, D]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+>b : B
+
+f14<A, B, D>(a, b, d);
+>f14<A, B, D>(a, b, d) : [A, B, D]
+>f14 : <T, U = V, V = C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+>b : B
+>d : D
+
+// function with two type parameters with defaults that mutually refer to each other
+declare function f15<T = U, U = T>(a?: T, b?: U): [T, U];
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+>T : T
+>U : U
+>U : U
+>T : T
+>a : T
+>T : T
+>b : U
+>U : U
+>T : T
+>U : U
+
+// inference
+f15();
+>f15() : [{}, {}]
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+
+f15(a);
+>f15(a) : [A, A]
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+>a : A
+
+f15(a, b);
+>f15(a, b) : [A, B]
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
+
+// no inference, partially supplied
+f15<A>();
+>f15<A>() : [A, A]
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+
+f15<A>(a);
+>f15<A>(a) : [A, A]
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+
+f15<A>(a, a);
+>f15<A>(a, a) : [A, A]
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>a : A
+
+// no inference, fully supplied
+f15<A, B>();
+>f15<A, B>() : [A, B]
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+
+f15<A, B>(a);
+>f15<A, B>(a) : [A, B]
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
+
+f15<A, B>(a, b);
+>f15<A, B>(a, b) : [A, B]
+>f15 : <T = U, U = T>(a?: T, b?: U) => [T, U]
+>A : A
+>B : B
+>a : A
+>b : B
+
+// function with a type parameter without a default and two type parameters with defaults that mutually refer to each other
+declare function f16<T, U = V, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>T : T
+>U : U
+>V : V
+>V : V
+>U : U
+>a : T
+>T : T
+>b : U
+>U : U
+>c : V
+>V : V
+>T : T
+>U : U
+>V : V
+
+// no inference
+f16();
+>f16() : [{}, {}, {}]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+
+f16(a);
+>f16(a) : [A, {}, {}]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+
+f16(a, b);
+>f16(a, b) : [A, B, B]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+
+f16(a, b, b);
+>f16(a, b, b) : [A, B, B]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+>b : B
+
+// no inference, partially supplied
+f16<A>();
+>f16<A>() : [A, {}, {}]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+
+f16<A>(a);
+>f16<A>(a) : [A, {}, {}]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+
+f16<A>(a, b);
+>f16<A>(a, b) : [A, {}, {}]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+
+f16<A>(a, b, b);
+>f16<A>(a, b, b) : [A, {}, {}]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+>b : B
+
+f16<A, B>();
+>f16<A, B>() : [A, B, B]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+
+f16<A, B>(a);
+>f16<A, B>(a) : [A, B, B]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+
+f16<A, B>(a, b);
+>f16<A, B>(a, b) : [A, B, B]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+
+f16<A, B>(a, b, b);
+>f16<A, B>(a, b, b) : [A, B, B]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+>b : B
+
+// no inference, fully supplied
+f16<A, B, D>();
+>f16<A, B, D>() : [A, B, D]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+
+f16<A, B, D>(a);
+>f16<A, B, D>(a) : [A, B, D]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+
+f16<A, B, D>(a, b);
+>f16<A, B, D>(a, b) : [A, B, D]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+>b : B
+
+f16<A, B, D>(a, b, d);
+>f16<A, B, D>(a, b, d) : [A, B, D]
+>f16 : <T, U = V, V = U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+>b : B
+>d : D
+
+// function with a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in a union
+declare function f17<T = U, U = T | B>(a?: T, b?: U): [T, U];
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>T : T
+>U : U
+>U : U
+>T : T
+>B : B
+>a : T
+>T : T
+>b : U
+>U : U
+>T : T
+>U : U
+
+// inference
+f17();
+>f17() : [{}, {} | B]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+
+f17(a);
+>f17(a) : [A, A | B]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>a : A
+
+f17(a, a);
+>f17(a, a) : [A, A]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>a : A
+>a : A
+
+f17(a, b);
+>f17(a, b) : [A, B]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
+
+f17(a, c);
+>f17(a, c) : [A, C]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>a : A
+>c : C
+
+// no inference, partially supplied
+f17<A>();
+>f17<A>() : [A, A | B]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+
+f17<A>(a);
+>f17<A>(a) : [A, A | B]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+
+f17<A>(a, a);
+>f17<A>(a, a) : [A, A | B]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>a : A
+
+f17<A>(a, b);
+>f17<A>(a, b) : [A, A | B]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>b : B
+
+// no inference, fully supplied
+f17<A, C>();
+>f17<A, C>() : [A, C]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+
+f17<A, C>(a);
+>f17<A, C>(a) : [A, C]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+
+f17<A, C>(a, c);
+>f17<A, C>(a, c) : [A, C]
+>f17 : <T = U, U = B | T>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+>c : C
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in a union
+declare function f18<T, U = V, V = U | C>(a?: T, b?: U, c?: V): [T, U, V];
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>T : T
+>U : U
+>V : V
+>V : V
+>U : U
+>C : C
+>a : T
+>T : T
+>b : U
+>U : U
+>c : V
+>V : V
+>T : T
+>U : U
+>V : V
+
+// inference
+f18();
+>f18() : [{}, {}, {} | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+
+f18(a);
+>f18(a) : [A, {}, {} | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+
+f18(a, b);
+>f18(a, b) : [A, B, B | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+
+f18(a, b, b);
+>f18(a, b, b) : [A, B, B]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+>b : B
+
+f18(a, b, c);
+>f18(a, b, c) : [A, B, C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+>c : C
+
+// no inference, partially supplied
+f18<A>();
+>f18<A>() : [A, {}, {} | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+
+f18<A>(a);
+>f18<A>(a) : [A, {}, {} | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+
+f18<A>(a, b);
+>f18<A>(a, b) : [A, {}, {} | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+
+f18<A>(a, b, b);
+>f18<A>(a, b, b) : [A, {}, {} | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+>b : B
+
+f18<A>(a, b, c);
+>f18<A>(a, b, c) : [A, {}, {} | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+>c : C
+
+f18<A, B>();
+>f18<A, B>() : [A, B, B | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+
+f18<A, B>(a);
+>f18<A, B>(a) : [A, B, B | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+
+f18<A, B>(a, b);
+>f18<A, B>(a, b) : [A, B, B | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+
+f18<A, B>(a, b, b);
+>f18<A, B>(a, b, b) : [A, B, B | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+>b : B
+
+f18<A, B>(a, b, c);
+>f18<A, B>(a, b, c) : [A, B, B | C]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+>c : C
+
+// no inference, fully supplied
+f18<A, B, D>();
+>f18<A, B, D>() : [A, B, D]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+
+f18<A, B, D>(a);
+>f18<A, B, D>(a) : [A, B, D]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+
+f18<A, B, D>(a, b);
+>f18<A, B, D>(a, b) : [A, B, D]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+>b : B
+
+f18<A, B, D>(a, b, d);
+>f18<A, B, D>(a, b, d) : [A, B, D]
+>f18 : <T, U = V, V = C | U>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+>b : B
+>d : D
+
+// function with a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f19<T = U, U = T & B>(a?: T, b?: U): [T, U];
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>T : T
+>U : U
+>U : U
+>T : T
+>B : B
+>a : T
+>T : T
+>b : U
+>U : U
+>T : T
+>U : U
+
+// inference
+f19();
+>f19() : [{}, {} & B]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+
+f19(a);
+>f19(a) : [A, A & B]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>a : A
+
+f19(a, a);
+>f19(a, a) : [A, A]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>a : A
+>a : A
+
+f19(a, b);
+>f19(a, b) : [A, B]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>a : A
+>b : B
+
+f19(a, ab);
+>f19(a, ab) : [A, AB]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>a : A
+>ab : AB
+
+f19(a, c);
+>f19(a, c) : [A, C]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>a : A
+>c : C
+
+// no inference, partially supplied
+f19<A>();
+>f19<A>() : [A, A & B]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+
+f19<A>(a);
+>f19<A>(a) : [A, A & B]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+
+f19<A>(a, ab);
+>f19<A>(a, ab) : [A, A & B]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>a : A
+>ab : AB
+
+// no inference, fully supplied
+f19<A, C>();
+>f19<A, C>() : [A, C]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+
+f19<A, C>(a);
+>f19<A, C>(a) : [A, C]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+
+f19<A, C>(a, c);
+>f19<A, C>(a, c) : [A, C]
+>f19 : <T = U, U = T & B>(a?: T, b?: U) => [T, U]
+>A : A
+>C : C
+>a : A
+>c : C
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f20<T, U = V, V = U & C>(a?: T, b?: U, c?: V): [T, U, V];
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>T : T
+>U : U
+>V : V
+>V : V
+>U : U
+>C : C
+>a : T
+>T : T
+>b : U
+>U : U
+>c : V
+>V : V
+>T : T
+>U : U
+>V : V
+
+// inference
+f20();
+>f20() : [{}, {}, {} & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+
+f20(a);
+>f20(a) : [A, {}, {} & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+
+f20(a, b);
+>f20(a, b) : [A, B, B & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+
+f20(a, b, c);
+>f20(a, b, c) : [A, B, C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>a : A
+>b : B
+>c : C
+
+// no inference, partially supplied
+f20<A>();
+>f20<A>() : [A, {}, {} & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+
+f20<A>(a);
+>f20<A>(a) : [A, {}, {} & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+
+f20<A>(a, b);
+>f20<A>(a, b) : [A, {}, {} & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+
+f20<A>(a, b, bc);
+>f20<A>(a, b, bc) : [A, {}, {} & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>a : A
+>b : B
+>bc : BC
+
+f20<A, B>();
+>f20<A, B>() : [A, B, B & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+
+f20<A, B>(a);
+>f20<A, B>(a) : [A, B, B & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+
+f20<A, B>(a, b);
+>f20<A, B>(a, b) : [A, B, B & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+
+f20<A, B>(a, b, bc);
+>f20<A, B>(a, b, bc) : [A, B, B & C]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>a : A
+>b : B
+>bc : BC
+
+// no inference, fully supplied
+f20<A, B, D>();
+>f20<A, B, D>() : [A, B, D]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+
+f20<A, B, D>(a);
+>f20<A, B, D>(a) : [A, B, D]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+
+f20<A, B, D>(a, b);
+>f20<A, B, D>(a, b) : [A, B, D]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+>b : B
+
+f20<A, B, D>(a, b, d);
+>f20<A, B, D>(a, b, d) : [A, B, D]
+>f20 : <T, U = V, V = U & C>(a?: T, b?: U, c?: V) => [T, U, V]
+>A : A
+>B : B
+>D : D
+>a : A
+>b : B
+>d : D
 
 interface i00<T = number> { a: T; }
 >i00 : i00<T>
@@ -559,6 +2239,68 @@ interface i04<T = number, U = string> {}
 >T : T
 >U : U
 
+interface i05<T = T> { a: T; }
+>i05 : i05<T>
+>T : T
+>T : T
+>a : T
+>T : T
+
+const i05c00 = (<i05>x).a;
+>i05c00 : {}
+>(<i05>x).a : {}
+>(<i05>x) : i05<{}>
+><i05>x : i05<{}>
+>i05 : i05<T>
+>x : any
+>a : {}
+
+const i05c01 = (<i05<number>>x).a;
+>i05c01 : number
+>(<i05<number>>x).a : number
+>(<i05<number>>x) : i05<number>
+><i05<number>>x : i05<number>
+>i05 : i05<T>
+>x : any
+>a : number
+
+interface i06<T = U, U = T> { a: [T, U]; }
+>i06 : i06<T, U>
+>T : T
+>U : U
+>U : U
+>T : T
+>a : [T, U]
+>T : T
+>U : U
+
+const i06c00 = (<i06>x).a;
+>i06c00 : [{}, {}]
+>(<i06>x).a : [{}, {}]
+>(<i06>x) : i06<{}, {}>
+><i06>x : i06<{}, {}>
+>i06 : i06<T, U>
+>x : any
+>a : [{}, {}]
+
+const i06c01 = (<i06<number>>x).a;
+>i06c01 : [number, number]
+>(<i06<number>>x).a : [number, number]
+>(<i06<number>>x) : i06<number, number>
+><i06<number>>x : i06<number, number>
+>i06 : i06<T, U>
+>x : any
+>a : [number, number]
+
+const i06c02 = (<i06<number, string>>x).a;
+>i06c02 : [number, string]
+>(<i06<number, string>>x).a : [number, string]
+>(<i06<number, string>>x) : i06<number, string>
+><i06<number, string>>x : i06<number, string>
+>i06 : i06<T, U>
+>x : any
+>a : [number, string]
+
 interface Base01<T> { a: T; }
 >Base01 : Base01<T>
 >T : T
diff --git a/tests/baselines/reference/genericDefaultsErrors.errors.txt b/tests/baselines/reference/genericDefaultsErrors.errors.txt
index ad2e4068590..2654f989804 100644
--- a/tests/baselines/reference/genericDefaultsErrors.errors.txt
+++ b/tests/baselines/reference/genericDefaultsErrors.errors.txt
@@ -1,88 +1,42 @@
-tests/cases/compiler/genericDefaultsErrors.ts(4,26): error TS2706: Type parameter 'T' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(5,26): error TS2706: Type parameter 'T' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(5,33): error TS2706: Type parameter 'U' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(6,29): error TS2705: Required type parameters may not follow optional type parameters.
-tests/cases/compiler/genericDefaultsErrors.ts(7,41): error TS2344: Type 'number' does not satisfy the constraint 'string'.
-tests/cases/compiler/genericDefaultsErrors.ts(8,59): error TS2344: Type 'T' does not satisfy the constraint 'number'.
+tests/cases/compiler/genericDefaultsErrors.ts(4,41): error TS2344: Type 'number' does not satisfy the constraint 'string'.
+tests/cases/compiler/genericDefaultsErrors.ts(5,59): error TS2344: Type 'T' does not satisfy the constraint 'number'.
   Type 'string' is not assignable to type 'number'.
-tests/cases/compiler/genericDefaultsErrors.ts(9,44): error TS2344: Type 'T' does not satisfy the constraint 'number'.
-tests/cases/compiler/genericDefaultsErrors.ts(10,39): error TS2344: Type 'number' does not satisfy the constraint 'T'.
-tests/cases/compiler/genericDefaultsErrors.ts(11,26): error TS2706: Type parameter 'T' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(11,33): error TS2706: Type parameter 'U' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(12,26): error TS2706: Type parameter 'T' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(12,33): error TS2706: Type parameter 'U' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(13,26): error TS2706: Type parameter 'T' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(13,33): error TS2706: Type parameter 'U' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(14,26): error TS2706: Type parameter 'T' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(14,33): error TS2706: Type parameter 'U' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(18,1): error TS2346: Supplied parameters do not match any signature of call target.
-tests/cases/compiler/genericDefaultsErrors.ts(21,1): error TS2346: Supplied parameters do not match any signature of call target.
-tests/cases/compiler/genericDefaultsErrors.ts(25,13): error TS2345: Argument of type '"a"' is not assignable to parameter of type 'number'.
-tests/cases/compiler/genericDefaultsErrors.ts(28,11): error TS2428: All declarations of 'i00' must have identical type parameters.
-tests/cases/compiler/genericDefaultsErrors.ts(31,11): error TS2428: All declarations of 'i01' must have identical type parameters.
-tests/cases/compiler/genericDefaultsErrors.ts(33,19): error TS2706: Type parameter 'T' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(34,19): error TS2706: Type parameter 'T' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(34,26): error TS2706: Type parameter 'U' has a circular default.
-tests/cases/compiler/genericDefaultsErrors.ts(35,22): error TS2705: Required type parameters may not follow optional type parameters.
-tests/cases/compiler/genericDefaultsErrors.ts(36,34): error TS2344: Type 'number' does not satisfy the constraint 'string'.
-tests/cases/compiler/genericDefaultsErrors.ts(37,52): error TS2344: Type 'T' does not satisfy the constraint 'number'.
+tests/cases/compiler/genericDefaultsErrors.ts(6,44): error TS2344: Type 'T' does not satisfy the constraint 'number'.
+tests/cases/compiler/genericDefaultsErrors.ts(7,39): error TS2344: Type 'number' does not satisfy the constraint 'T'.
+tests/cases/compiler/genericDefaultsErrors.ts(11,1): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/genericDefaultsErrors.ts(14,1): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/genericDefaultsErrors.ts(18,13): error TS2345: Argument of type '"a"' is not assignable to parameter of type 'number'.
+tests/cases/compiler/genericDefaultsErrors.ts(21,11): error TS2428: All declarations of 'i00' must have identical type parameters.
+tests/cases/compiler/genericDefaultsErrors.ts(24,11): error TS2428: All declarations of 'i01' must have identical type parameters.
+tests/cases/compiler/genericDefaultsErrors.ts(26,27): error TS2705: Required type parameters may not follow optional type parameters.
+tests/cases/compiler/genericDefaultsErrors.ts(27,34): error TS2344: Type 'number' does not satisfy the constraint 'string'.
+tests/cases/compiler/genericDefaultsErrors.ts(28,52): error TS2344: Type 'T' does not satisfy the constraint 'number'.
   Type 'string' is not assignable to type 'number'.
-tests/cases/compiler/genericDefaultsErrors.ts(38,37): error TS2344: Type 'T' does not satisfy the constraint 'number'.
-tests/cases/compiler/genericDefaultsErrors.ts(39,32): error TS2344: Type 'number' does not satisfy the constraint 'T'.
-tests/cases/compiler/genericDefaultsErrors.ts(42,15): error TS2707: Generic type 'i09<T, U, V>' requires between 2 and 3 type arguments.
-tests/cases/compiler/genericDefaultsErrors.ts(43,15): error TS2707: Generic type 'i09<T, U, V>' requires between 2 and 3 type arguments.
-tests/cases/compiler/genericDefaultsErrors.ts(46,15): error TS2707: Generic type 'i09<T, U, V>' requires between 2 and 3 type arguments.
-tests/cases/compiler/genericDefaultsErrors.ts(48,17): error TS2367: Type parameter 'T' cannot be referenced outside of a declaration that defines it.
+tests/cases/compiler/genericDefaultsErrors.ts(29,37): error TS2344: Type 'T' does not satisfy the constraint 'number'.
+tests/cases/compiler/genericDefaultsErrors.ts(30,32): error TS2344: Type 'number' does not satisfy the constraint 'T'.
+tests/cases/compiler/genericDefaultsErrors.ts(33,15): error TS2707: Generic type 'i09<T, U, V>' requires between 2 and 3 type arguments.
+tests/cases/compiler/genericDefaultsErrors.ts(34,15): error TS2707: Generic type 'i09<T, U, V>' requires between 2 and 3 type arguments.
+tests/cases/compiler/genericDefaultsErrors.ts(37,15): error TS2707: Generic type 'i09<T, U, V>' requires between 2 and 3 type arguments.
+tests/cases/compiler/genericDefaultsErrors.ts(39,17): error TS2367: Type parameter 'T' cannot be referenced outside of a declaration that defines it.
 
 
-==== tests/cases/compiler/genericDefaultsErrors.ts (33 errors) ====
+==== tests/cases/compiler/genericDefaultsErrors.ts (18 errors) ====
     
     declare const x: any;
     
-    declare function f00<T = T>(): void;
-                             ~
-!!! error TS2706: Type parameter 'T' has a circular default.
-    declare function f01<T = U, U = T>(): void;
-                             ~
-!!! error TS2706: Type parameter 'T' has a circular default.
-                                    ~
-!!! error TS2706: Type parameter 'U' has a circular default.
-    declare function f02<T = U, U>();
-                                ~
-!!! error TS2705: Required type parameters may not follow optional type parameters.
-    declare function f03<T extends string = number>(): void;
+    declare function f03<T extends string = number>(): void; // error
                                             ~~~~~~
 !!! error TS2344: Type 'number' does not satisfy the constraint 'string'.
-    declare function f04<T extends string, U extends number = T>(): void;
+    declare function f04<T extends string, U extends number = T>(): void; // error
                                                               ~
 !!! error TS2344: Type 'T' does not satisfy the constraint 'number'.
 !!! error TS2344:   Type 'string' is not assignable to type 'number'.
-    declare function f05<T, U extends number = T>(): void;
+    declare function f05<T, U extends number = T>(): void; // error
                                                ~
 !!! error TS2344: Type 'T' does not satisfy the constraint 'number'.
-    declare function f06<T, U extends T = number>(): void;
+    declare function f06<T, U extends T = number>(): void; // error
                                           ~~~~~~
 !!! error TS2344: Type 'number' does not satisfy the constraint 'T'.
-    declare function f07<T = U, U = T | { a: number }>(): void;
-                             ~
-!!! error TS2706: Type parameter 'T' has a circular default.
-                                    ~~~~~~~~~~~~~~~~~
-!!! error TS2706: Type parameter 'U' has a circular default.
-    declare function f08<T = U, U = T & { a: number }>(): void;
-                             ~
-!!! error TS2706: Type parameter 'T' has a circular default.
-                                    ~~~~~~~~~~~~~~~~~
-!!! error TS2706: Type parameter 'U' has a circular default.
-    declare function f09<T = U, U = T | { a: number }>(): void;
-                             ~
-!!! error TS2706: Type parameter 'T' has a circular default.
-                                    ~~~~~~~~~~~~~~~~~
-!!! error TS2706: Type parameter 'U' has a circular default.
-    declare function f10<T = U, U = T & { a: number }>(): void;
-                             ~
-!!! error TS2706: Type parameter 'T' has a circular default.
-                                    ~~~~~~~~~~~~~~~~~
-!!! error TS2706: Type parameter 'U' has a circular default.
     
     declare function f11<T, U, V = number>(): void;
     f11(); // ok
@@ -111,16 +65,8 @@ tests/cases/compiler/genericDefaultsErrors.ts(48,17): error TS2367: Type paramet
               ~~~
 !!! error TS2428: All declarations of 'i01' must have identical type parameters.
     
-    interface i02<T = T> { } // error
-                      ~
-!!! error TS2706: Type parameter 'T' has a circular default.
-    interface i03<T = U, U = T> { } // error
-                      ~
-!!! error TS2706: Type parameter 'T' has a circular default.
-                             ~
-!!! error TS2706: Type parameter 'U' has a circular default.
-    interface i04<T = U, U> { } // error
-                         ~
+    interface i04<T = number, U> { } // error
+                              ~
 !!! error TS2705: Required type parameters may not follow optional type parameters.
     interface i05<T extends string = number> { } // error
                                      ~~~~~~
diff --git a/tests/baselines/reference/genericDefaultsErrors.js b/tests/baselines/reference/genericDefaultsErrors.js
index d8ab04cdadf..7e91d72fb21 100644
--- a/tests/baselines/reference/genericDefaultsErrors.js
+++ b/tests/baselines/reference/genericDefaultsErrors.js
@@ -2,17 +2,10 @@
 
 declare const x: any;
 
-declare function f00<T = T>(): void;
-declare function f01<T = U, U = T>(): void;
-declare function f02<T = U, U>();
-declare function f03<T extends string = number>(): void;
-declare function f04<T extends string, U extends number = T>(): void;
-declare function f05<T, U extends number = T>(): void;
-declare function f06<T, U extends T = number>(): void;
-declare function f07<T = U, U = T | { a: number }>(): void;
-declare function f08<T = U, U = T & { a: number }>(): void;
-declare function f09<T = U, U = T | { a: number }>(): void;
-declare function f10<T = U, U = T & { a: number }>(): void;
+declare function f03<T extends string = number>(): void; // error
+declare function f04<T extends string, U extends number = T>(): void; // error
+declare function f05<T, U extends number = T>(): void; // error
+declare function f06<T, U extends T = number>(): void; // error
 
 declare function f11<T, U, V = number>(): void;
 f11(); // ok
@@ -31,9 +24,7 @@ interface i00<U = number> { } // error
 interface i01<T = number> { } // ok
 interface i01<T = string> { } // error
 
-interface i02<T = T> { } // error
-interface i03<T = U, U = T> { } // error
-interface i04<T = U, U> { } // error
+interface i04<T = number, U> { } // error
 interface i05<T extends string = number> { } // error
 interface i06<T extends string, U extends number = T> { } // error
 interface i07<T, U extends number = T> { } // error
@@ -61,25 +52,10 @@ f12("a"); // error
 
 //// [genericDefaultsErrors.d.ts]
 declare const x: any;
-declare function f00<T = T>(): void;
-declare function f01<T = U, U = T>(): void;
-declare function f02<T = U, U>(): any;
 declare function f03<T extends string = number>(): void;
 declare function f04<T extends string, U extends number = T>(): void;
 declare function f05<T, U extends number = T>(): void;
 declare function f06<T, U extends T = number>(): void;
-declare function f07<T = U, U = T | {
-    a: number;
-}>(): void;
-declare function f08<T = U, U = T & {
-    a: number;
-}>(): void;
-declare function f09<T = U, U = T | {
-    a: number;
-}>(): void;
-declare function f10<T = U, U = T & {
-    a: number;
-}>(): void;
 declare function f11<T, U, V = number>(): void;
 declare function f12<T, U = T>(a?: U): void;
 interface i00<T> {
@@ -90,11 +66,7 @@ interface i01<T = number> {
 }
 interface i01<T = string> {
 }
-interface i02<T = T> {
-}
-interface i03<T = U, U = T> {
-}
-interface i04<T = U, U> {
+interface i04<T = number, U> {
 }
 interface i05<T extends string = number> {
 }
diff --git a/tests/cases/compiler/genericDefaults.ts b/tests/cases/compiler/genericDefaults.ts
index df507a32a91..3e9db09bfa9 100644
--- a/tests/cases/compiler/genericDefaults.ts
+++ b/tests/cases/compiler/genericDefaults.ts
@@ -1,68 +1,398 @@
 // @declaration: true
+interface A { a: number; }
+interface B { b: number; }
+interface C { c: number; }
+interface D { d: number; }
+interface AB { a: number; b: number; }
+interface BC { b: number; c: number; }
+
+declare const a: A;
+declare const b: B;
+declare const c: C;
+declare const d: D;
+declare const ab: AB;
+declare const bc: BC;
 declare const x: any;
 
-declare function f00<T = number>(a?: T): T;
-const f00c00 = f00();
-const f00c01 = f00(1);
-const f00c02 = f00("a");
-const f00c03 = f00<number>();
-const f00c04 = f00<number>(1);
-const f00c05 = f00<string>("a");
+// function without type parameters
+declare function f00(a?: A): A;
+// no inference
+f00();
+f00(a);
 
-declare function f01<T, U = T>(a?: T, b?: U): [T, U];
-const f01c00 = f01();
-const f01c01 = f01(1);
-const f01c02 = f01(1, "a");
-const f01c03 = f01<number>();
-const f01c04 = f01<number>(1);
-const f01c05 = f01<number>(1, 2);
-const f01c06 = f01<number, string>();
-const f01c07 = f01<number, string>(1);
-const f01c08 = f01<number, string>(1, "a");
+// function with a type parameter without a default
+declare function f01<T>(a?: T): T;
+// inference
+f01();
+f01(a);
+// no inference, fully supplied
+f01<A>();
+f01<A>(a);
 
-declare function f02<T extends number, U = T>(a?: T, b?: U): [T, U];
-const f02c00 = f02();
-const f02c01 = f02(1);
-const f02c02 = f02(1, "a");
-const f02c03 = f02<number>();
-const f02c04 = f02<number>(1);
-const f02c05 = f02<number>(1, 2);
-const f02c06 = f02<number, string>();
-const f02c07 = f02<number, string>(1);
-const f02c08 = f02<number, string>(1, "a");
+// function with a type paramter with a default
+declare function f02<T = A>(a?: T): T;
+// inference
+f02();
+f02(a);
+f02(b);
+// no inference, fully supplied
+f02<A>();
+f02<A>(a);
+f02<B>();
+f02<B>(b);
 
-declare function f03<T extends number, U extends T = T>(a?: T, b?: U): [T, U];
-const f03c00 = f03();
-const f03c01 = f03(1);
-const f03c02 = f03(1, 1);
-const f03c03 = f03<number>();
-const f03c04 = f03<number>(1);
-const f03c05 = f03<number>(1, 2);
-const f03c06 = f03<number, number>();
-const f03c07 = f03<number, number>(1);
-const f03c08 = f03<number, number>(1, 2);
+// function with a type parameter with a default that refers to itself
+declare function f03<T = T>(a?: T): T;
+// inference
+f03();
+f03(a);
+f03(b);
+// no inference, fully supplied
+f03<A>();
+f03<A>(a);
+f03<B>();
+f03<B>(b);
 
-declare function f04<T, U = T | { a: number }>(a?: T, b?: U): [T, U];
-const f04c00 = f04();
-const f04c01 = f04(1);
-const f04c02 = f04(1, 1);
-const f04c03 = f04<number>();
-const f04c04 = f04<number>(1);
-const f04c05 = f04<number>(1, 2);
-const f04c06 = f04<number, number>();
-const f04c07 = f04<number, number>(1);
-const f04c08 = f04<number, number>(1, 2);
+// function with a type paramter without a default and a type parameter with a default
+declare function f04<T, U = B>(a?: T, b?: U): [T, U];
+// inference
+f04();
+f04(a);
+f04(a, b);
+f04(a, c);
+// no inference, partially supplied
+f04<A>();
+f04<A>(a);
+f04<A>(a, b);
+// no inference, fully supplied
+f04<A, B>();
+f04<A, B>(a);
+f04<A, B>(a, b);
+f04<A, C>();
+f04<A, C>(a);
+f04<A, C>(a, c);
 
-declare function f05<T, U = T & { b: number }>(a?: T, b?: U): [T, U];
-const f05c00 = f05();
-const f05c01 = f05(1);
-const f05c02 = f05(1, 1);
-const f05c03 = f05<number>();
-const f05c04 = f05<number>(1);
-const f05c05 = f05<{ a: number }>({ a: 1 }, { a: 2, b: 3});
-const f05c06 = f05<number, number>();
-const f05c07 = f05<number, number>(1);
-const f05c08 = f05<number, number>(1, 2);
+// function with a type parameter without a default and a type parameter with a default that refers to an earlier type parameter
+declare function f05<T, U = T>(a?: T, b?: U): [T, U];
+// inference
+f05();
+f05(a);
+f05(a, a);
+f05(a, b);
+// no inference, partially supplied
+f05<A>();
+f05<A>(a);
+f05<A>(a, a);
+// no inference, fully supplied
+f05<A, B>();
+f05<A, B>(a);
+f05<A, B>(a, b);
+
+// function with a type parameter with a default that refers to an earlier type parameter with a default
+declare function f06<T = A, U = T>(a?: T, b?: U): [T, U];
+// inference
+f06();
+f06(a);
+f06(a, a);
+f06(a, b);
+f06(b, a);
+f06(b, b);
+// no inference, partially supplied
+f06<A>();
+f06<A>(a);
+f06<A>(a, a);
+f06<B>();
+f06<B>(b);
+f06<B>(b, b);
+// no inference, fully supplied
+f06<A, B>();
+f06<A, B>(a);
+f06<A, B>(a, b);
+f06<B, C>();
+f06<B, C>(b);
+f06<B, C>(b, c);
+
+// function with a type parameter without a default and a type parameter with a default that refers to an earlier type parameter with a default
+declare function f07<T, U = B, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+// inference
+f07();
+f07(a, b);
+f07(a, c);
+f07(a, b, b);
+f07(a, b, c);
+f07(a, c, b);
+f07(a, c, c);
+// no inference, partially supplied
+f07<A>();
+f07<A>(a);
+f07<A>(a, b);
+f07<A>(a, b, b);
+f07<A, B>();
+f07<A, B>(a);
+f07<A, B>(a, b);
+f07<A, B>(a, b, b);
+f07<A, C>();
+f07<A, C>(a);
+f07<A, C>(a, c);
+f07<A, C>(a, c, c);
+// no inference, fully supplied
+f07<A, B, C>();
+f07<A, B, C>(a);
+f07<A, B, C>(a, b);
+f07<A, B, C>(a, b, c);
+f07<A, C, A>();
+f07<A, C, A>(a);
+f07<A, C, D>(a, c);
+f07<A, C, D>(a, c, d);
+
+// function with a type parameter with a default that refers to an earlier type parameter with a constraint
+declare function f08<T extends A, U = T>(a?: T, b?: U): [T, U];
+// inference
+f08();
+f08(a);
+f08(a, a);
+f08(a, b);
+// no inference, partially supplied
+f08<A>();
+f08<A>(a);
+f08<A>(a, a);
+// no inference, fully supplied
+f08<A, B>();
+f08<A, B>(a);
+f08<A, B>(a, b);
+
+// function with a type parameter with a constraint and a default that refers to an earlier type parameter
+declare function f09<T, U extends T = T>(a?: T, b?: U): [T, U];
+// inference
+f09();
+f09(a);
+f09(a, a);
+f09(a, ab);
+// no inference, partially supplied
+f09<A>();
+f09<A>(a);
+f09<A>(a, a);
+f09<A>(a, ab);
+// no inference, fully supplied
+f09<A, AB>();
+f09<A, AB>(a);
+f09<A, AB>(a, ab);
+
+// function with a type parameter with a constraint and a default that refers to an earlier type parameter with a constraint
+declare function f10<T extends A, U extends T = T>(a?: T, b?: U): [T, U];
+// inference
+f10();
+f10(a);
+f10(a, a);
+f10(a, ab);
+// no inference, partially supplied
+f10<A>();
+f10<A>(a);
+f10<A>(a, a);
+f10<A>(a, ab);
+// no inference, fully supplied
+f10<A, A>();
+f10<A, A>(a);
+f10<A, A>(a, a);
+f10<A, A>(a, ab);
+f10<A, AB>();
+f10<A, AB>(a);
+f10<A, AB>(a, ab);
+
+// function with a type parameter with a default that refers to an earier type parameter in a union
+declare function f11<T, U = T | B>(a?: T, b?: U): [T, U];
+// inference
+f11();
+f11(a);
+f11(a, a);
+f11(a, b);
+f11(a, c);
+// no inference, partially supplied
+f11<A>();
+f11<A>(a);
+f11<A>(a, a);
+f11<A>(a, b);
+// no inference, fully supplied
+f11<A, C>();
+f11<A, C>(a);
+f11<A, C>(a, c);
+
+// function with a type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f12<T, U = T & B>(a?: T, b?: U): [T, U];
+// inference
+f12();
+f12(a);
+f12(a, a);
+f12(a, b);
+f12(a, c);
+// no inference, partially supplied
+f12<A>();
+f12<A>(a);
+f12<A>(a, ab);
+// no inference, fully supplied
+f12<A, C>();
+f12<A, C>(a);
+f12<A, C>(a, c);
+
+// function with a type parameter with a default that refers to a later type parameter with a default
+declare function f13<T = U, U = B>(a?: T, b?: U): [T, U];
+// inference
+f13();
+f13(a);
+f13(a, b);
+f13(a, c);
+// no inference, partially supplied
+f13<A>();
+f13<A>(a);
+f13<A>(a, b);
+// no inference, fully supplied
+f13<A, C>();
+f13<A, C>(a);
+f13<A, C>(a, c);
+f13<A, C>(a, c);
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default
+declare function f14<T, U = V, V = C>(a?: T, b?: U, c?: V): [T, U, V];
+// inference
+f14();
+f14(a);
+f14(a, b);
+f14(a, b, c);
+f14(a, b, d);
+// no inference, partially supplied
+f14<A>();
+f14<A>(a);
+f14<A>(a, b);
+f14<A>(a, b, c);
+f14<A, B>();
+f14<A, B>(a);
+f14<A, B>(a, b);
+f14<A, B>(a, b, c);
+// no inference fully supplied
+f14<A, B, D>();
+f14<A, B, D>(a);
+f14<A, B, D>(a, b);
+f14<A, B, D>(a, b, d);
+
+// function with two type parameters with defaults that mutually refer to each other
+declare function f15<T = U, U = T>(a?: T, b?: U): [T, U];
+// inference
+f15();
+f15(a);
+f15(a, b);
+// no inference, partially supplied
+f15<A>();
+f15<A>(a);
+f15<A>(a, a);
+// no inference, fully supplied
+f15<A, B>();
+f15<A, B>(a);
+f15<A, B>(a, b);
+
+// function with a type parameter without a default and two type parameters with defaults that mutually refer to each other
+declare function f16<T, U = V, V = U>(a?: T, b?: U, c?: V): [T, U, V];
+// no inference
+f16();
+f16(a);
+f16(a, b);
+f16(a, b, b);
+// no inference, partially supplied
+f16<A>();
+f16<A>(a);
+f16<A>(a, b);
+f16<A>(a, b, b);
+f16<A, B>();
+f16<A, B>(a);
+f16<A, B>(a, b);
+f16<A, B>(a, b, b);
+// no inference, fully supplied
+f16<A, B, D>();
+f16<A, B, D>(a);
+f16<A, B, D>(a, b);
+f16<A, B, D>(a, b, d);
+
+// function with a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in a union
+declare function f17<T = U, U = T | B>(a?: T, b?: U): [T, U];
+// inference
+f17();
+f17(a);
+f17(a, a);
+f17(a, b);
+f17(a, c);
+// no inference, partially supplied
+f17<A>();
+f17<A>(a);
+f17<A>(a, a);
+f17<A>(a, b);
+// no inference, fully supplied
+f17<A, C>();
+f17<A, C>(a);
+f17<A, C>(a, c);
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in a union
+declare function f18<T, U = V, V = U | C>(a?: T, b?: U, c?: V): [T, U, V];
+// inference
+f18();
+f18(a);
+f18(a, b);
+f18(a, b, b);
+f18(a, b, c);
+// no inference, partially supplied
+f18<A>();
+f18<A>(a);
+f18<A>(a, b);
+f18<A>(a, b, b);
+f18<A>(a, b, c);
+f18<A, B>();
+f18<A, B>(a);
+f18<A, B>(a, b);
+f18<A, B>(a, b, b);
+f18<A, B>(a, b, c);
+// no inference, fully supplied
+f18<A, B, D>();
+f18<A, B, D>(a);
+f18<A, B, D>(a, b);
+f18<A, B, D>(a, b, d);
+
+// function with a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f19<T = U, U = T & B>(a?: T, b?: U): [T, U];
+// inference
+f19();
+f19(a);
+f19(a, a);
+f19(a, b);
+f19(a, ab);
+f19(a, c);
+// no inference, partially supplied
+f19<A>();
+f19<A>(a);
+f19<A>(a, ab);
+// no inference, fully supplied
+f19<A, C>();
+f19<A, C>(a);
+f19<A, C>(a, c);
+
+// function with a type parameter without a default and a type parameter with a default that refers to a later type parameter with a default that refers to an earlier type parameter in an intersection
+declare function f20<T, U = V, V = U & C>(a?: T, b?: U, c?: V): [T, U, V];
+// inference
+f20();
+f20(a);
+f20(a, b);
+f20(a, b, c);
+// no inference, partially supplied
+f20<A>();
+f20<A>(a);
+f20<A>(a, b);
+f20<A>(a, b, bc);
+f20<A, B>();
+f20<A, B>(a);
+f20<A, B>(a, b);
+f20<A, B>(a, b, bc);
+// no inference, fully supplied
+f20<A, B, D>();
+f20<A, B, D>(a);
+f20<A, B, D>(a, b);
+f20<A, B, D>(a, b, d);
 
 interface i00<T = number> { a: T; }
 const i00c00 = (<i00>x).a;
@@ -91,6 +421,15 @@ interface i04<T> {}
 interface i04<T = number> {}
 interface i04<T = number, U = string> {}
 
+interface i05<T = T> { a: T; }
+const i05c00 = (<i05>x).a;
+const i05c01 = (<i05<number>>x).a;
+
+interface i06<T = U, U = T> { a: [T, U]; }
+const i06c00 = (<i06>x).a;
+const i06c01 = (<i06<number>>x).a;
+const i06c02 = (<i06<number, string>>x).a;
+
 interface Base01<T> { a: T; }
 interface Base01Constructor { new <T = number>(a?: T): Base01<T>; }
 
diff --git a/tests/cases/compiler/genericDefaultsErrors.ts b/tests/cases/compiler/genericDefaultsErrors.ts
index 02b4fce9296..4ea42beb3da 100644
--- a/tests/cases/compiler/genericDefaultsErrors.ts
+++ b/tests/cases/compiler/genericDefaultsErrors.ts
@@ -2,17 +2,10 @@
 
 declare const x: any;
 
-declare function f00<T = T>(): void;
-declare function f01<T = U, U = T>(): void;
-declare function f02<T = U, U>();
-declare function f03<T extends string = number>(): void;
-declare function f04<T extends string, U extends number = T>(): void;
-declare function f05<T, U extends number = T>(): void;
-declare function f06<T, U extends T = number>(): void;
-declare function f07<T = U, U = T | { a: number }>(): void;
-declare function f08<T = U, U = T & { a: number }>(): void;
-declare function f09<T = U, U = T | { a: number }>(): void;
-declare function f10<T = U, U = T & { a: number }>(): void;
+declare function f03<T extends string = number>(): void; // error
+declare function f04<T extends string, U extends number = T>(): void; // error
+declare function f05<T, U extends number = T>(): void; // error
+declare function f06<T, U extends T = number>(): void; // error
 
 declare function f11<T, U, V = number>(): void;
 f11(); // ok
@@ -31,9 +24,7 @@ interface i00<U = number> { } // error
 interface i01<T = number> { } // ok
 interface i01<T = string> { } // error
 
-interface i02<T = T> { } // error
-interface i03<T = U, U = T> { } // error
-interface i04<T = U, U> { } // error
+interface i04<T = number, U> { } // error
 interface i05<T extends string = number> { } // error
 interface i06<T extends string, U extends number = T> { } // error
 interface i07<T, U extends number = T> { } // error