fix: strictly check operator overload ambiguity (#2762)

Operator overload is an internal mechanism, it can support to compare user-defined class, but it need to be limited. a == b and b == a should run the same function and get the same result in semantic level. Allowing ambiguity is bug prone.

Author: HerrCai0907

src/compiler.ts

@@ -51,6 +51,7 @@
 "Index signature accessors in type '{0}' differ in types.": 237,
 "Initializer, definitive assignment or nullable type expected.": 238,
 "Definitive assignment has no effect on local variables.": 239,
+"Ambiguous operator overload '{0}' (conflicting overloads '{1}' and '{2}').": 240,
 
 "Importing the table disables some indirect call optimizations.": 901,
 "Exporting the table disables some indirect call optimizations.": 902,

src/diagnosticMessages.json

@@ -390,8 +390,10 @@ export namespace OperatorKind{
 caseToken.GreaterThan_GreaterThan_Equals: returnOperatorKind.BitwiseShr;
 caseToken.GreaterThan_GreaterThan_GreaterThan:
 caseToken.GreaterThan_GreaterThan_GreaterThan_Equals: returnOperatorKind.BitwiseShrU;
-caseToken.Equals_Equals: returnOperatorKind.Eq;
-caseToken.Exclamation_Equals: returnOperatorKind.Ne;
+caseToken.Equals_Equals: 
+caseToken.Equals_Equals_Equals: returnOperatorKind.Eq;
+caseToken.Exclamation_Equals: 
+caseToken.Exclamation_Equals_Equals: returnOperatorKind.Ne;
 caseToken.GreaterThan: returnOperatorKind.Gt;
 caseToken.GreaterThan_Equals: returnOperatorKind.Ge;
 caseToken.LessThan: returnOperatorKind.Lt;

src/program.ts

@@ -10,7 +10,9 @@ import{
 import{
 Class,
 Program,
-DecoratorFlags
+DecoratorFlags,
+OperatorKind,
+Function
 }from"./program";
 
 import{
@@ -320,6 +322,14 @@ export class Type{
 returnnull;
 }
 
+lookupOverload(kind: OperatorKind,program: Program): Function|null{
+letclassReference=this.getClassOrWrapper(program);
+if(classReference){
+returnclassReference.lookupOverload(kind);
+}
+returnnull;
+}
+
 /** Gets the underlying function signature of this type, if any. */
 getSignature(): Signature|null{
 returnthis.isInternalReference

src/types.ts

@@ -0,0 +1,14 @@
+{
+"asc_flags": [],
+"stderr": [
+"AS240: Ambiguous operator overload '==' (conflicting overloads 'operator-overload-ambiguity/A#__eq' and 'operator-overload-ambiguity/B#__eq').",
+"compare_nonnull_a == compare_nonnull_b;",
+"AS240: Ambiguous operator overload '==' (conflicting overloads 'operator-overload-ambiguity/B#__eq' and 'operator-overload-ambiguity/A#__eq').",
+"compare_nonnull_b == compare_nonnull_a;",
+"AS240: Ambiguous operator overload '==' (conflicting overloads 'operator-overload-ambiguity/C.__eq' and 'operator-overload-ambiguity/D#__eq').",
+"compare_nonnull_c == compare_nonnull_d;",
+"AS240: Ambiguous operator overload '==' (conflicting overloads 'operator-overload-ambiguity/A#__eq' and 'operator-overload-ambiguity/B#__eq').",
+"compare_extend_1 == compare_extend_2;",
+"EOF"
+ ]
+}

tests/compiler/operator-overload-ambiguity.json

@@ -0,0 +1,38 @@
+classA{
+ @operator("==")__eq(other: B): bool{
+returntrue;
+}
+}
+classB{
+ @operator("==")__eq(other: A): bool{
+returntrue;
+}
+}
+exportfunctioncompare_nonnull(compare_nonnull_a: A,compare_nonnull_b: B): void{
+compare_nonnull_a==compare_nonnull_b;
+compare_nonnull_b==compare_nonnull_a;
+}
+
+classC{
+ @operator("==")static__eq(self: C|null,other: D|null): bool{
+returntrue;
+}
+}
+classD{
+ @operator("==")__eq(other: i32): bool{
+returntrue;
+}
+}
+exportfunctioncompare_null(compare_nonnull_c: C|null,compare_nonnull_d: D|null): void{
+compare_nonnull_c==compare_nonnull_d;
+}
+
+classPAextendsA{}
+classPBextendsB{}
+exportfunctioncompare_extend(compare_extend_1: PA,compare_extend_2: PB): void{
+compare_extend_1==compare_extend_2;
+}
+
+exportfunctionend(): void{
+ERROR("EOF");
+}