Merge pull request #7608 from slavapestov/more-generic-subscript-pre-gardening

More preliminary gardening for generic subscripts

Author: slavapestov

include/swift/AST/Decl.h

@@ -1399,13 +1399,13 @@ class GenericContext : public DeclContext {
     : DeclContext(Kind, Parent) { }
 
 public:
-  /// \brief Retrieve the set of parameters to a generic subscript, or null if
-  /// this subscript is not generic.
+  /// \brief Retrieve the set of parameters to a generic context, or null if
+  /// this context is not generic.
   GenericParamList *getGenericParams() const { return GenericParams; }
 
   void setGenericParams(GenericParamList *GenericParams);
 
-  /// \brief Determine whether this subscript has generic parameters
+  /// \brief Determine whether this context has generic parameters
   /// of its own.
   bool isGeneric() const { return GenericParams != nullptr; }
 
@@ -1419,10 +1419,10 @@ class GenericContext : public DeclContext {
     TrailingWhere = trailingWhereClause;
   }
 
-  /// Retrieve the generic signature for this subscript.
+  /// Retrieve the generic signature for this context.
   GenericSignature *getGenericSignature() const;
 
-  /// Retrieve the generic context for this subscript.
+  /// Retrieve the generic context for this context.
   GenericEnvironment *getGenericEnvironment() const;
 
   /// Retrieve the innermost generic parameter types.
@@ -1446,7 +1446,7 @@ class GenericContext : public DeclContext {
                                  GenericSignature *genericSig,
                                  uint64_t genericEnvData);
 
-  /// Set the generic context of this subscript.
+  /// Set the generic context of this context.
   void setGenericEnvironment(GenericEnvironment *genericEnv);
 };
 

lib/Sema/TypeCheckDecl.cpp

@@ -4812,35 +4812,12 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       gp->setOuterParameters(FD->getDeclContext()->getGenericParamsOfContext());
 
       auto *sig = TC.validateGenericFuncSignature(FD);
-
-      // Create a fresh generic signature builder.
-      GenericSignatureBuilder builder(
-                             FD->getASTContext(),
-                             LookUpConformanceInModule(FD->getModuleContext()));
-      auto *parentSig = FD->getDeclContext()->getGenericSignatureOfContext();
-      TC.checkGenericParamList(&builder, gp, parentSig, nullptr);
-
-      // Infer requirements from parameter patterns.
-      for (auto pattern : FD->getParameterLists()) {
-        builder.inferRequirements(pattern, gp);
-      }
-
-      // Infer requirements from the result type.
-      if (!FD->getBodyResultTypeLoc().isNull()) {
-        unsigned depth = gp->getDepth();
-        builder.inferRequirements(FD->getBodyResultTypeLoc(),
-                                  /*minDepth=*/depth,
-                                  /*maxDepth=*/depth);
-      }
+      auto *env = sig->createGenericEnvironment(*FD->getModuleContext());
+      FD->setGenericEnvironment(env);
 
       // Revert the types within the signature so it can be type-checked with
       // archetypes below.
       TC.revertGenericFuncSignature(FD);
-
-      // Assign archetypes.
-      builder.finalize(FD->getLoc(), sig->getGenericParams());
-      auto *env = sig->createGenericEnvironment(*FD->getModuleContext());
-      FD->setGenericEnvironment(env);
     } else if (FD->getDeclContext()->getGenericSignatureOfContext()) {
       (void)TC.validateGenericFuncSignature(FD);
       // Revert all of the types within the signature of the function.
@@ -6458,24 +6435,12 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       gp->setOuterParameters(CD->getDeclContext()->getGenericParamsOfContext());
 
       auto *sig = TC.validateGenericFuncSignature(CD);
-
-      GenericSignatureBuilder builder(
-                             CD->getASTContext(),
-                             LookUpConformanceInModule(CD->getModuleContext()));
-      auto *parentSig = CD->getDeclContext()->getGenericSignatureOfContext();
-      TC.checkGenericParamList(&builder, gp, parentSig, nullptr);
-
-      // Infer requirements from the parameters of the constructor.
-      builder.inferRequirements(CD->getParameterList(1), gp);
+      auto *env = sig->createGenericEnvironment(*CD->getModuleContext());
+      CD->setGenericEnvironment(env);
 
       // Revert the types within the signature so it can be type-checked with
       // archetypes below.
       TC.revertGenericFuncSignature(CD);
-
-      // Assign archetypes.
-      builder.finalize(CD->getLoc(), sig->getGenericParams());
-      auto *env = sig->createGenericEnvironment(*CD->getModuleContext());
-      CD->setGenericEnvironment(env);
     } else if (CD->getDeclContext()->getGenericSignatureOfContext()) {
       (void)TC.validateGenericFuncSignature(CD);
 

test/Constraints/same_types.swift

@@ -95,11 +95,10 @@ func fail4<T: Barrable>(_ t: T) -> (Y, Z)
   return (t.bar, t.bar.foo) // expected-error{{cannot convert return expression of type 'X' to return type 'Z'}}
 }
 
-// TODO: repeat diagnostic
 func fail5<T: Barrable>(_ t: T) -> (Y, Z)
   where
   T.Bar.Foo == Z,
-  T.Bar == Y { // expected-error 2{{generic parameter 'T.Bar.Foo' cannot be equal to both 'Z' and 'X'}}
+  T.Bar == Y { // expected-error{{generic parameter 'T.Bar.Foo' cannot be equal to both 'Z' and 'X'}}
   return (t.bar, t.bar.foo) // expected-error{{cannot convert return expression of type 'X' to return type 'Z'}}
 }
 
@@ -110,7 +109,7 @@ func testAssocTypeEquivalence<T: Fooable>(_ fooable: T) -> X.Type
   return T.Foo.self
 }
 
-func fail6<T>(_ t: T) -> Int where T == Int { // expected-error 2{{same-type requirement makes generic parameter 'T' non-generic}}
+func fail6<T>(_ t: T) -> Int where T == Int { // expected-error{{same-type requirement makes generic parameter 'T' non-generic}}
   return t
 }
 
@@ -161,7 +160,7 @@ struct S1<T : P> {
 S1<Q>().foo(x: 1, y: 2)
 
 struct S2<T : P> where T.A == T.B {
-  func foo<X, Y>(x: X, y: Y) where X == T.A, Y == T.B {  // expected-error 2{{same-type requirement makes generic parameters 'X' and 'Y' equivalent}}
+  func foo<X, Y>(x: X, y: Y) where X == T.A, Y == T.B {  // expected-error{{same-type requirement makes generic parameters 'X' and 'Y' equivalent}}
     print(X.self)
     print(Y.self)
     print(x)
@@ -171,7 +170,7 @@ struct S2<T : P> where T.A == T.B {
 S2<Q>().foo(x: 1, y: 2)
 
 struct S3<T : P> {
-  func foo<X, Y>(x: X, y: Y) where X == T.A, Y == T.A {} // expected-error 2{{same-type requirement makes generic parameters 'X' and 'Y' equivalent}}
+  func foo<X, Y>(x: X, y: Y) where X == T.A, Y == T.A {} // expected-error{{same-type requirement makes generic parameters 'X' and 'Y' equivalent}}
 }
 S3<Q>().foo(x: 1, y: 2)
 
@@ -211,33 +210,27 @@ protocol P1 {
 func structuralSameType1<A: P1, B: P1, T, U, V, W>(_: A, _: B, _: T, _: U, _: V, _: W)
   where A.Assoc == X1<T, U>, B.Assoc == X1<V, W>, A.Assoc == B.Assoc { }
 // expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
-// expected-error@-2{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
-// expected-error@-3{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
-// expected-error@-4{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+// expected-error@-2{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
 
 typealias Tuple2<T, U> = (T, U)
 
 func structuralSameType2<A: P1, B: P1, T, U, V, W>(_: A, _: B, _: T, _: U, _: V, _: W)
   where A.Assoc == Tuple2<T, U>, B.Assoc == Tuple2<V, W>, A.Assoc == B.Assoc { }
 // expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
-// expected-error@-2{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
-// expected-error@-3{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
-// expected-error@-4{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+// expected-error@-2{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
 
 func structuralSameType3<T, U, V, W>(_: T, _: U, _: V, _: W)
   where X1<T, U> == X1<V, W> { }
 // expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
-// expected-error@-2{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
-// expected-error@-3{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
-// expected-error@-4{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+// expected-error@-2{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
 
 protocol P2 {
   associatedtype Assoc1
   associatedtype Assoc2
 }
 
 func structuralSameTypeRecursive1<T: P2, U>(_: T, _: U)
-  where T.Assoc1 == Tuple2<T.Assoc1, U> // expected-error 2{{same-type constraint 'T.Assoc1' == '(T.Assoc1, U)' is recursive}}
+  where T.Assoc1 == Tuple2<T.Assoc1, U> // expected-error{{same-type constraint 'T.Assoc1' == '(T.Assoc1, U)' is recursive}}
 { }
 
 

test/Generics/function_defs.swift

@@ -295,4 +295,4 @@ func badTypeConformance1<T>(_: T) where Int : EqualComparable {} // expected-err
 func badTypeConformance2<T>(_: T) where T.Blarg : EqualComparable { } // expected-error{{'Blarg' is not a member type of 'T'}}
 
 func badSameType<T, U : GeneratesAnElement, V>(_ : T)
-  where T == U.Element, U.Element == V {} // expected-error 2{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
+  where T == U.Element, U.Element == V {} // expected-error{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}

test/Generics/superclass_constraint.swift

@@ -32,9 +32,8 @@ func f8<T : GA<A>>(_: T) where T : GA<B> {} // expected-error{{generic parameter
 func f9<T : GA<A>>(_: T) where T : GB<A> {}
 func f10<T : GB<A>>(_: T) where T : GA<A> {}
 
-// FIXME: Extra diagnostics because we're re-building the archetype builder.
-func f11<T : GA<T>>(_: T) { } // expected-error 2{{superclass constraint 'T' : 'GA<T>' is recursive}}
-func f12<T : GA<U>, U : GB<T>>(_: T, _: U) { } // expected-error 2{{superclass constraint 'U' : 'GB<T>' is recursive}} // expected-error 2{{superclass constraint 'T' : 'GA<U>' is recursive}}
+func f11<T : GA<T>>(_: T) { } // expected-error{{superclass constraint 'T' : 'GA<T>' is recursive}}
+func f12<T : GA<U>, U : GB<T>>(_: T, _: U) { } // expected-error{{superclass constraint 'U' : 'GB<T>' is recursive}} // expected-error{{superclass constraint 'T' : 'GA<U>' is recursive}}
 func f13<T : U, U : GA<T>>(_: T, _: U) { } // expected-error{{inheritance from non-protocol, non-class type 'U'}}
 
 // rdar://problem/24730536