[test] fix tests

Author: angela-laar

include/swift/AST/NameLookup.h

@@ -31,15 +31,12 @@
 
 namespace swift {
 class ASTContext;
-class ASTWalker;
 class DeclName;
 class Type;
 class TypeDecl;
 class ValueDecl;
 struct SelfBounds;
 class NominalTypeDecl;
-class Evaluator;
-
 namespace ast_scope {
 class ASTSourceFileScope;
 class ASTScopeImpl;
@@ -644,7 +641,8 @@ class FindLocalVal : public StmtVisitor<FindLocalVal> {
   void visitDoCatchStmt(DoCatchStmt *S);
 
 };
-  
+
+
 /// The bridge between the legacy UnqualifiedLookupFactory and the new ASTScope
 /// lookup system
 class AbstractASTScopeDeclConsumer {

lib/AST/NameLookup.cpp

@@ -2820,31 +2820,28 @@ CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r, ASTContext
         if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome))
           return Action::SkipChildren();
       }
-      
-      if (Ctx.LangOpts.hasFeature(Feature::ImplicitSome)) {
-        if (auto existential = dyn_cast<ExistentialTypeRepr>(repr)) {
-          auto generic = dyn_cast<GenericIdentTypeRepr>(existential->getConstraint());
-          if(generic)
-            Reprs.push_back(existential);
-          auto meta = dyn_cast<MetatypeTypeRepr>(existential->getConstraint());
-          Action::VisitChildrenIf(meta || generic);
-        }
 
-        if (auto compositionRepr = dyn_cast<CompositionTypeRepr>(repr)) {
-          if (!compositionRepr->isTypeReprAny())
-            Reprs.push_back(compositionRepr);
-          return Action::SkipChildren();
-        } else if (auto generic = dyn_cast<GenericIdentTypeRepr>(repr)) {
-          if (!Reprs.empty() && isa<ExistentialTypeRepr>(Reprs.front())){
-              Reprs.clear();
-              Action::Continue();
-          }
-          Reprs.push_back(generic);
-        } else if (auto identRepr = dyn_cast<IdentTypeRepr>(repr)) {
-          if (identRepr->isProtocol(dc))
-            Reprs.push_back(identRepr);
+      if (!Ctx.LangOpts.hasFeature(Feature::ImplicitSome))
+        return Action::Continue();
+      
+      if (auto existential = dyn_cast<ExistentialTypeRepr>(repr)) {
+        auto meta = dyn_cast<MetatypeTypeRepr>(existential->getConstraint());
+        auto generic = dyn_cast<GenericIdentTypeRepr>(existential->getConstraint());
+        if(generic)
+          Reprs.push_back(existential);
+        return Action::VisitChildrenIf(meta || generic);
+      } else if (auto compositionRepr = dyn_cast<CompositionTypeRepr>(repr)) {
+        if (!compositionRepr->isTypeReprAny())
+          Reprs.push_back(compositionRepr);
+        return Action::SkipChildren();
+      } else if (auto generic = dyn_cast<GenericIdentTypeRepr>(repr)) {
+        // prevent any P<some P>
+        if (!Reprs.empty() && isa<ExistentialTypeRepr>(Reprs.front())){
+          Reprs.clear();
         }
- 
+      } else if (auto identRepr = dyn_cast<IdentTypeRepr>(repr)) {
+        if (identRepr->isProtocol(dc))
+          Reprs.push_back(identRepr);
       }
       return Action::Continue();
     }

lib/Sema/TypeCheckGeneric.cpp

@@ -30,7 +30,6 @@
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace swift;
-using namespace swift::namelookup;
 
 //
 // Generic functions
@@ -167,7 +166,6 @@ OpaqueResultTypeRequest::evaluate(Evaluator &evaluator,
       genericParamTypes.push_back(paramType);
 
       TypeRepr *constraint = currentRepr;
-      //auto *constraint = currentRepr;
 
       if (auto opaqueReturn = dyn_cast<OpaqueReturnTypeRepr>(currentRepr)){
         constraint = opaqueReturn->getConstraint();

test/type/implicit_some/opaque_parameters.swift

@@ -11,52 +11,38 @@ protocol Q {
 
 extension Int: P { }
 extension String: P { }
+extension Array: P { }
+extension Set: Q {
+  typealias A = String
 
-// expected-note@+1{{requirement from conditional conformance of '[Double]' to 'Q'}}
-extension Array: Q where Element: P, Element: Equatable {
-  func f() -> Element {
-    return first!
-  }
-
-  func takesA(_: Element) {}
-}
-
-extension Set: Q where Element: P, Element: Equatable { // expected-warning {{redundant conformance constraint 'Element' : 'Equatable'}}
-  func f() -> Element {
-    return first!
-  }
-
-  func takesA(_: Element) {}
+  func f() -> String { }
+  func takesA(_: String) { }
 }
 
-// expected-note@+2{{where 'Q' = 'Int'}}
-// expected-note@+1{{in call to function 'takesImplicitQ'}}
 func takesImplicitQ(_ q: Q) -> Bool {
   // expected-error@+1 {{cannot convert value of type 'Int' to expected argument type '(Q).A'}}
   q.takesA(1)
 
   return q.f() == q.f()
 }
 
-func testTakesImplicitQ(arrayOfInts: [Int], setOfStrings: Set<String>, i: Int) {
-  _ = takesImplicitQ(arrayOfInts)
-  _ = takesImplicitQ(setOfStrings)
-  _ = takesImplicitQ(i) // expected-error{{global function 'takesImplicitQ' requires that 'Int' conform to 'Q'}}
+func testParam(_ a: Collection) -> Bool  {
+  a.isEmpty
+}
 
-  let f = takesImplicitQ // expected-error{{generic parameter 'Q' could not be inferred}}
-  let _: ([String]) -> Bool = takesImplicitQ
-  let _: ([Double]) -> Bool = takesImplicitQ // expected-error{{global function 'takesImplicitQ' requires that 'Double' conform to 'P'}}
-  _ = f
+func testMultiple(_ a: Collection, _ b: Collection) -> Bool  {
+  a.count == b.count
 }
 
-// expected-note@+1{{where 'some P' = '[Int]'}}
-func takeMultiple<T>(_: T, _: some Q, _: some P) { }
+// expected-note@+1{{where 'P' = 'Set<String>'}}
+func takeMultiple<T>(_: T, _: Q, _: P) { }
 
 func testTakeMultiple(
   arrayOfInts: [Int], setOfStrings: Set<String>, i: Int, d: Double
 ) {
-  takeMultiple(d, arrayOfInts, i)
-  takeMultiple(d, arrayOfInts, arrayOfInts) // expected-error{{global function 'takeMultiple' requires that '[Int]' conform to 'P'}}
+  takeMultiple(d, setOfStrings, i)
+  takeMultiple(d,setOfStrings, arrayOfInts)
+  takeMultiple(d, setOfStrings, setOfStrings) // expected-error{{global function 'takeMultiple' requires that 'Set<String>' conform to 'P'}}
 }
 
 // inout
@@ -67,15 +53,17 @@ func testInOut() {
   implicitInOut(&i)
 }
 
-// Combine with parameterized protocol types
-protocol PrimaryCollection<Element>: Collection {}
+// Prohibit use of opaque parameters in consuming positions.
+typealias FnType<T> = (T) -> Void
+
+func consumingA(fn: (P) -> Void) { } // expected-error{{'some' cannot appear in parameter position in parameter type '(P) -> Void'}}
+func consumingB(fn: FnType<P>) { } // expected-error{{'some' cannot appear in parameter position in parameter type '(P) -> Void'}}
 
-extension Array: PrimaryCollection { }
-extension Set: PrimaryCollection { }
 
+// TO-DO Handle plain generic opaque parameters
 func takePrimaryCollections(
-  _ strings: PrimaryCollection<String>,
-  _ ints : PrimaryCollection<Int>
+  _ strings:some  Collection<String>,
+  _ ints : some Collection<Int>
 ) {
   for s in strings {
     let _: String = s
@@ -85,9 +73,9 @@ func takePrimaryCollections(
     let _: Int = i
   }
 }
-
+// TO-DO Handle plain generic opaque parameters
 func takeMatchedPrimaryCollections<T: Equatable>(
-  _ first: PrimaryCollection<T>, _ second: PrimaryCollection<T>
+  _ first: some Collection<T>, _ second: some Collection<T>
 ) -> Bool {
   first.elementsEqual(second)
 }
@@ -100,9 +88,3 @@ func testPrimaries(
   _ = takeMatchedPrimaryCollections(arrayOfInts, setOfInts)
   _ = takeMatchedPrimaryCollections(arrayOfInts, setOfStrings) // expected-error{{type of expression is ambiguous without more context}}
 }
-
-// Prohibit use of opaque parameters in consuming positions.
-typealias FnType<T> = (T) -> Void
-
-func consumingA(fn: (P) -> Void) { } // expected-error{{'some' cannot appear in parameter position in parameter type '(P) -> Void'}}
-func consumingB(fn: FnType<P>) { } // expected-error{{'some' cannot appear in parameter position in parameter type '(P) -> Void'}}

test/type/implicit_some/opaque_return.swift

@@ -21,19 +21,19 @@ class SeasonalMenu : Cafe {
   func treats()  {}
 }
 
-func getCurrentMenu () -> some Cafe {
+func getCurrentMenu() -> some Cafe {
   return SeasonalMenu()
 }
 
 var cafe = getCurrentMenu()
 cafe.breakfast()
 cafe.treats()
 
-// Type alias + custom protocols
+// Type alias + protocols
 typealias Snack = Shop & Cafe
 typealias Meal = Eatery
 
-struct CoffeeShop(): Snack {
+struct CoffeeShop: Snack {
   func coffee(){ }
   func breakfast() { }
   func treats(){ }
@@ -54,7 +54,7 @@ class TopTier: Eatery {
 func find() -> Eatery { } // expected-error {{function declares an opaque return type, but has no return statements in its body from which to infer an underlying type}}
 
 func find() -> AnyObject {
-  return CoffeeShop() // expected-error {{return expression of type 'CoffeeBar' expected to be an instance of a class or class-constrained type}}
+  return CoffeeShop() // expected-error {{return expression of type 'CoffeeShop' expected to be an instance of a class or class-constrained type}}
 }
 
 func find() -> Any {
@@ -83,23 +83,23 @@ protocol Basket {
   associatedtype Fruit
   associatedtype MiniBasket: Basket where MiniBasket.Fruit == Fruit
 
-  var fruits: [Fruit] { get set }
-  var minibaskets: [MiniBasket] { get set }
+  var fruit: [Fruit] { get set }
+  var minifruitbasket: [MiniBasket] { get set }
 }
 
 struct MyFruit : Basket {
-  var fruits: [String]
-  var minibaskets: [FruitforFriend]
+  var fruit: [String]
+  var minifruitbasket: [OtherFruit]
 }
 
-struct FruitforFriend : Basket {
-  var fruits: [String]
-  var minibaskets: [FruitforFriend]
+struct OtherFruit : Basket {
+  var fruit: [String]
+  var minifruitbasket: [OtherFruit]
 }
 
 func eat(_ myfruit: inout Basket) -> Basket {
-  myfruit.fruits.removeLast()
-  myfruit.minibaskets.removeLast()
+  myfruit.fruit.removeLast()
+  myfruit.minifruitbasket.removeLast()
   return myfruit
 }
 

test/type/opaque_parameters.swift

@@ -1,5 +1,4 @@
 // RUN: %target-typecheck-verify-swift -disable-availability-checking -warn-redundant-requirements
-// RUN: %target-typecheck-verify-swift -disable-availability-checking -warn-redundant-requirements -enable-experimental-implicit-some
 
 protocol P { }