Add tests for operator lookup and redeclaration checking

Author: hamishknight

test/decl/operator/Inputs/lookup_moduleA.swift

@@ -0,0 +1,36 @@
+
+// Only declared in module A.
+prefix operator >>>
+public prefix func >>> (rhs: Int) {}
+
+precedencegroup DeclaredInModuleA {}
+
+// Declared in both modules A and B.
+infix operator ???
+precedencegroup DeclaredInModulesAB {}
+
+// Declared in both modules A and B, but with a different
+// precedence group in each.
+infix operator ???? : DeclaredInModuleA
+
+// Declared in both modules A and B, but shadowed by lookup_other.
+precedencegroup DeclaredInModulesABShadowed {}
+
+// Declared in both modules A and B.
+postfix operator <?
+
+// Declared in both modules A and B, and also the stdlib.
+precedencegroup TernaryPrecedence {}
+
+// Also declared in module 'ExportsAC', which shadows this decl.
+precedencegroup ShadowsModuleA {}
+
+// Also declared in modules ExportsAC and C.
+precedencegroup ShadowsModulesAC {}
+
+// Also declared in modules C and ExportsAC.
+infix operator ?????
+
+// Also declared in modules C and ExportsAC, but with a different
+// precedencegroup.
+infix operator ?????? : DeclaredInModuleA

test/decl/operator/Inputs/lookup_moduleB.swift

@@ -0,0 +1,31 @@
+
+// Both of these decls are also declared in lookup_other, and we should prefer
+// those decls.
+precedencegroup DeclaredAcrossFiles {}
+infix operator &&&
+
+// Also declared in module A.
+infix operator ???
+precedencegroup DeclaredInModulesAB {}
+
+// Also declared in module A, but with a different precedence group.
+infix operator ????
+
+// Declared in both modules A and B, but shadowed by lookup_other.
+precedencegroup DeclaredInModulesABShadowed {}
+
+// Also declared in module A.
+postfix operator <?
+
+// Declared in both modules A and B, and also the stdlib.
+precedencegroup TernaryPrecedence {}
+
+// These are both also declared in module ExportsAC.
+infix operator ???!
+precedencegroup DeclaredInModulesBExportsAC {}
+
+// Also declared in module ExportsAC, but with a different precedence group.
+infix operator ????!
+
+// Also declared in module ExportsAC.
+postfix operator <!

test/decl/operator/Inputs/lookup_moduleC.swift

@@ -0,0 +1,9 @@
+
+// Also declared in modules ExportsAC and A.
+precedencegroup ShadowsModulesAC {}
+
+// Also declared in modules A and ExportsAC.
+infix operator ?????
+
+// Also declared in modules A and ExportsAC, with a different precedencegroup.
+infix operator ?????? : ShadowsModulesAC

test/decl/operator/Inputs/lookup_moduleD.swift

@@ -0,0 +1,2 @@
+
+precedencegroup DeclaredInModuleD {}

test/decl/operator/Inputs/lookup_module_exportsAC.swift

@@ -0,0 +1,26 @@
+
+@_exported import A
+@_exported import C
+
+// Also declared in module A, but this decl shadows it.
+precedencegroup ShadowsModuleA {}
+
+// Also declared in modules A and C, but this decl shadows it.
+precedencegroup ShadowsModulesAC {}
+
+// Also declared in modules A and C, but this decl shadows it.
+infix operator ?????
+
+// Also declared in modules A and C, but with a different precedencegroup.
+// However that shouldn't impact shadowing.
+infix operator ??????
+
+// These are both also declared in module B.
+infix operator ???!
+precedencegroup DeclaredInModulesBExportsAC {}
+
+// Also declared in module B, but with a different precedence group.
+infix operator ????! : ShadowsModuleA
+
+// Also declared in module B.
+postfix operator <!

test/decl/operator/Inputs/lookup_other.swift

@@ -0,0 +1,13 @@
+
+@_exported import D
+
+// Both of these decls are also declared in module B, but we should prefer
+// these decls.
+precedencegroup DeclaredAcrossFiles {
+  higherThan: AssignmentPrecedence
+  associativity: left
+}
+infix operator &&& : DeclaredAcrossFiles
+
+// Declared in both modules A and B, but shadowed by this decl.
+precedencegroup DeclaredInModulesABShadowed {}

test/decl/operator/Inputs/lookup_other2.swift

@@ -0,0 +1,2 @@
+
+@_exported import D

test/decl/operator/Inputs/lookup_other_compat.swift

@@ -0,0 +1,3 @@
+
+// Also declared in the files being tested.
+precedencegroup RedeclaredInModule {}

test/decl/operator/Inputs/redeclaration_other_compat.swift

@@ -0,0 +1,10 @@
+precedencegroup RedeclaredAcrossFiles {}
+
+infix operator ^^^
+prefix operator >>>
+postfix operator <<<
+
+precedencegroup P1 {}
+infix operator ^^^^ : P1
+
+infix operator &&&

test/decl/operator/lookup_compatibility.swift

@@ -0,0 +1,127 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend -emit-module %S/Inputs/lookup_moduleD.swift -module-name D -o %t -I %t
+// RUN: %target-swift-frontend -emit-module %S/Inputs/lookup_moduleC.swift -module-name C -o %t -I %t
+// RUN: %target-swift-frontend -emit-module %S/Inputs/lookup_moduleB.swift -module-name B -o %t -I %t
+// RUN: %target-swift-frontend -emit-module %S/Inputs/lookup_moduleA.swift -module-name A -o %t -I %t
+// RUN: %target-swift-frontend -emit-module %S/Inputs/lookup_module_exportsAC.swift -module-name ExportsAC -o %t -I %t
+
+// FIXME: Remove -verify-ignore-unknown.
+// RUN: %target-swift-frontend -typecheck -verify -verify-ignore-unknown -primary-file %s %S/Inputs/lookup_other.swift %S/Inputs/lookup_other2.swift %S/Inputs/lookup_other_compat.swift -I %t
+
+import ExportsAC
+import B
+
+infix operator ^^^ : DeclaredAcrossFiles
+func ^^^ (lhs: Int, rhs: Int) -> Int { 0 }
+func &&& (lhs: Int, rhs: Int) -> Int { 0 }
+
+// FIXME(SR-12132): The operator decl >>> is declared in module A, which we
+// should be able to see through ExportsAC.
+prefix func >>> (rhs: Double) {} // expected-error {{operator implementation without matching operator declaration}}
+
+// FIXME(SR-12132): We should also see precedencegroups in module A through
+// ExportsAC.
+infix operator ^^^^ : DeclaredInModuleA // expected-error {{unknown precedence group 'DeclaredInModuleA'}}
+
+// The operator decl for ??? is declared in both modules A and B, but has the
+// same default precedence group in both, so there's no ambiguity.
+func ??? (lhs: Int, rhs: Int) {}
+
+// Same for ???!, declared in modules ExportsAC and B, but has the same
+// precedence group in both.
+func ???! (lhs: Int, rhs: Int) {}
+
+// The operator decl for ???? is declared in both modules A and B, and has a
+// different precedence group in each. This should therefore be ambiguous.
+// However, for compatibility, we don't look through exports in other modules,
+// so we don't see the one in module A.
+func ???? (lhs: Int, rhs: Int) {}
+
+// The operator decl for ????! is declared in both modules ExportsAC and B, and
+// has a different precedence group in each. Therefore ambiguous.
+// FIXME: We shouldn't emit the unknown operator decl error.
+func ????! (lhs: Int, rhs: Int) {} // expected-error {{ambiguous operator declarations found for operator}}
+// expected-error@-1 {{operator implementation without matching operator declaration}}
+
+// Same as ????, the precedencegroup is declared in both modules A and B, but
+// we don't look into module A for compatibility.
+infix operator <?> : DeclaredInModulesAB
+
+// The precedencegroup is declared in both modules ExportsAC and B, therefore
+// ambiguous.
+// FIXME: We shouldn't emit the 'unknown precedence group' error.
+infix operator <!> : DeclaredInModulesBExportsAC // expected-error {{multiple precedence groups found}}
+// expected-error@-1 {{unknown precedence group 'DeclaredInModulesBExportsAC'}}
+
+// This precedencegroup is declared in this module as well as in both modules A
+// and B. The decl in this module should shadow the imported ones, but for
+// compatibility we don't see module A's decl and take module B's decl.
+infix operator <??> : DeclaredInModulesABShadowed
+
+// The operator decl for <? is declared in both modules A and B, but there's no
+// meaningful difference between the declarations, so legal.
+postfix func <? (lhs: Int) {}
+
+// Same thing, <! is declared in both modules ExportsAC and B, but there's no
+// meaningful difference between the declarations, so legal.
+postfix func <! (lhs: Int) {}
+
+// This precedencegroup is declared in both modules A and ExportsAC, but the
+// latter shadows the former.
+infix operator <???> : ShadowsModuleA
+
+// This precedencegroup is declared in modules A, C, and ExportsAC, but the
+// latter shadows both of the former.
+infix operator <????> : ShadowsModulesAC
+
+// This operator decl is declared in modules A, C, and ExportsAC, but the
+// latter shadows both of the former.
+func ????? (lhs: Int, rhs: Int) {}
+
+// This operator decl is declared in modules A, C, and ExportsAC, but the
+// latter shadows both of the former, despite them having different
+// precedencegroups.
+func ?????? (lhs: Int, rhs: Int) {}
+
+// FIXME: Module D is imported through exports in both lookup_other and
+// lookup_other2, but we fail to detect the fact that we're visiting the same
+// thing twice.
+infix operator <> : DeclaredInModuleD // expected-error {{unknown precedence group 'DeclaredInModuleD'}}
+
+// Also declared in lookup_other. To preserve compatibility, we allow an
+// unambiguous lookup that will favor this declaration over lookup_other.
+precedencegroup RedeclaredInModule {} 
+infix operator *** : RedeclaredInModule // Okay.
+
+func testOperatorLookup() {
+  // In lookup_other, DeclaredAcrossFiles is left associative, whereas in
+  // module B it is non-associative. Make sure we use module B's for
+  // compatibility.
+  _ = 5 ^^^ 5 ^^^ 5
+  // expected-error@-1 {{adjacent operators are in unordered precedence groups 'AssignmentPrecedence' and 'DeclaredAcrossFiles'}}
+  // expected-error@-2 {{adjacent operators are in non-associative precedence group 'DeclaredAcrossFiles'}}
+  // expected-error@-3 {{cannot convert value of type '()' to expected argument type 'Int'}}
+
+  // Same for &&&, in lookup_other it is declared as left associative.
+  _ = 5 &&& 5 &&& 5 // expected-error {{adjacent operators are in non-associative precedence group 'DefaultPrecedence'}}
+
+  // The operator >>> is declared in module A, which we should be able to see
+  // through ExportsAC.
+  >>>1
+
+  // We've been evil and overriden TernaryPrecedence in both modules A and B.
+  // FIXME: We shouldn't emit the 'broken stdlib' error.
+  true ? () : () // expected-error {{multiple precedence groups found}}
+  // expected-error@-1 {{broken standard library: missing builtin precedence group 'TernaryPrecedence'}}
+}
+
+precedencegroup CastingPrecedence {
+  lowerThan: AssignmentPrecedence
+}
+
+func testBuiltinPrecedenceGroupOverriding() {
+  // Evil, but allowed.
+  var x = 0
+  x = 0 as Int // expected-error {{cannot convert value of type '()' to type 'Int' in coercion}}
+}

test/decl/operator/redeclaration_compatibility.swift

@@ -0,0 +1,32 @@
+// RUN: %target-swift-frontend -typecheck -verify -primary-file %s %S/Inputs/redeclaration_other_compat.swift
+
+// We currently allow cross-file redeclarations.
+precedencegroup RedeclaredAcrossFiles {}
+
+precedencegroup RedeclaredSameFile {} // expected-note {{previous precedence group declaration here}}
+precedencegroup RedeclaredSameFile {} // expected-error {{precedence group redeclared}}
+
+precedencegroup RedeclaredSameFile2 { // expected-note {{previous precedence group declaration here}}
+  assignment: true
+}
+precedencegroup RedeclaredSameFile2 {} // expected-error {{precedence group redeclared}}
+
+// These are all declared in the other file, and so are allowed for now.
+infix operator ^^^
+prefix operator >>>
+postfix operator <<<
+infix operator ^^^^
+
+// This is declared as an infix operator in the other file, so no problem.
+prefix operator &&&
+postfix operator &&&
+
+infix operator %%% // expected-note {{previous operator declaration here}}
+infix operator %%% // expected-error {{operator redeclared}}
+
+prefix operator %%% // expected-note {{previous operator declaration here}}
+prefix operator %%% // expected-error {{operator redeclared}}
+
+precedencegroup P2 {}
+infix operator *** : P2 // expected-note {{previous operator declaration here}}
+infix operator *** // expected-error {{operator redeclared}}