 protocol Conforms: Parent where T: Foo {}
 extension Conforms { func foo(_: T) {} }
 func needsConforms<X: Conforms>(_: X.Type) {
-    needsFoo(X.T.self)
+  needsFoo(X.T.self)
 }
 struct ConcreteConforms: Conforms {
-    typealias T = Int
+  typealias T = Int
 }
 struct BadConcreteConforms: Conforms {
-    // expected-error@-1 {{type 'BadConcreteConforms.T' (aka 'String') does not conform to protocol 'Foo'}}
-    typealias T = String
+  // expected-error@-1 {{type 'BadConcreteConforms.T' (aka 'String') does not conform to protocol 'Foo'}}
+  typealias T = String
 }
 
 protocol SameType: Parent, SecondParent where T == U { }
 func needsSameTypeProtocol<X: SameType>(_: X.Type) {
-    needsSameType(X.T.self, X.U.self)
+  needsSameType(X.T.self, X.U.self)
 }
 struct ConcreteSameType: SameType {
-    typealias T = Int
-    typealias U = Int
+  typealias T = Int
+  typealias U = Int
 }
 struct BadConcreteSameType: SameType { // expected-error{{'SameType' requires the types 'BadConcreteSameType.T' (aka 'Int') and 'BadConcreteSameType.U' (aka 'Float') be equivalent}}
 	// expected-note@-1{{requirement specified as 'Self.T' == 'Self.U' [with Self = BadConcreteSameType]}}
-    typealias T = Int
-    typealias U = Float
+  typealias T = Int
+  typealias U = Float
 }
 
 protocol NestedConforms: SecondParent where U: Parent, U.T: Foo2 {}
 func needsNestedConforms<X: NestedConforms>(_: X.Type) {
-    needsParent(X.U.self)
-    needsFoo2(X.U.T.self)
+  needsParent(X.U.self)
+  needsFoo2(X.U.T.self)
 }
 struct ConcreteNestedConforms: NestedConforms {
-    typealias U = ConcreteParent
+  typealias U = ConcreteParent
 }
 struct BadConcreteNestedConforms: NestedConforms {
   // expected-error@-1 {{type 'ConcreteParentNonFoo2.T' (aka 'Float') does not conform to protocol 'Foo2'}}

struct ConcreteParentNonFoo2: Parent { typealias T = Float }

protocol SecondParent {
    associatedtype U
}
struct ConcreteSecondParent: SecondParent { typealias U = Int }
struct ConcreteSecondParent2: SecondParent { typealias U = Int }

extension Float: Foo {}

protocol Parent {
  associatedtype T
}
func needsParent<X: Parent>(_: X.Type) {}
struct ConcreteParent: Parent { typealias T = Int }
