fix bugs

Author: HerrCai0907

src/compiler.ts

@@ -395,13 +395,6 @@ export const enum RuntimeFeatures{
 setArgumentsLength=1<<6
 }
 
-classCheckBinaryOperatorOverloadResult{
-constructor(
-publicoverload: Function|null,
-publicisAmbiguity: bool,
-){}
-}
-
 /** Imported default names of compiler-generated elements. */
 exportnamespaceImportNames{
 /** Name of the default namespace */
@@ -3790,22 +3783,6 @@ export class Compiler extends DiagnosticEmitter{
 privatei32PowInstance: Function|null=null;
 privatei64PowInstance: Function|null=null;
 
-privatecheckCommutativeBinaryOperatorOverload(
-leftType: Type,rightType: Type,token: Token,reportNode: Expression
-): CheckBinaryOperatorOverloadResult{
-// check operator overload
-constoperator=OperatorKind.fromBinaryToken(token);
-constleftOverload=leftType.lookupOverload(operator,this.program);
-constrightOverload=rightType.lookupOverload(operator,this.program);
-if(leftOverload&&rightOverload&&leftOverload!=rightOverload){
-this.error(DiagnosticCode.Operator_0_overloading_ambiguity,reportNode.range,operatorTokenToString(token));
-returnnewCheckBinaryOperatorOverloadResult(null,true);
-}
-if(leftOverload)returnnewCheckBinaryOperatorOverloadResult(leftOverload,false);
-if(rightOverload)returnnewCheckBinaryOperatorOverloadResult(rightOverload,false);
-returnnewCheckBinaryOperatorOverloadResult(null,false);
-}
-
 privatecompileCommutativeBinaryExpression(
 expression: BinaryExpression,
 contextualType: Type,
@@ -3828,21 +3805,32 @@ export class Compiler extends DiagnosticEmitter{
 
 rightExpr=this.compileExpression(right,leftType);
 rightType=this.currentType;
-
-letcheckOverloadResult=this.checkCommutativeBinaryOperatorOverload(leftType,rightType,operator,expression);
-if(checkOverloadResult.isAmbiguity){
+
+// check operator overload
+constoperatorKind=OperatorKind.fromBinaryToken(operator);
+constleftOverload=leftType.lookupOverload(operatorKind,this.program);
+constrightOverload=rightType.lookupOverload(operatorKind,this.program);
+if(leftOverload&&rightOverload&&leftOverload!=rightOverload){
+this.error(DiagnosticCode.Operator_0_overloading_ambiguity,expression.range,operatorTokenToString(operator));
 this.currentType=contextualType;
 returnmodule.unreachable();
 }
-letoverload=checkOverloadResult.overload;
-if(overload){
+if(leftOverload){
 returnthis.compileCommutativeBinaryOverload(
-overload,
+leftOverload,
 left,leftExpr,leftType,
 right,rightExpr,rightType,
 expression
 );
 }
+if(rightOverload){
+returnthis.compileCommutativeBinaryOverload(
+rightOverload,
+right,rightExpr,rightType,
+left,leftExpr,leftType,
+expression
+);
+}
 constsignednessIsRelevant=
 operator==Token.LessThan||
 operator==Token.GreaterThan||
@@ -5493,24 +5481,24 @@ export class Compiler extends DiagnosticEmitter{
 
 privatecompileCommutativeBinaryOverload(
 operatorInstance: Function,
-left: Expression,
-leftExpr: ExpressionRef,
-leftType: Type,
-right: Expression,
-rightExpr: ExpressionRef,
-rightType: Type,
+first: Expression,
+firstExpr: ExpressionRef,
+firstType: Type,
+second: Expression,
+secondExpr: ExpressionRef,
+secondType: Type,
 reportNode: Node
 ): ExpressionRef{
 letsignature=operatorInstance.signature;
 letparameterTypes=signature.parameterTypes;
 if(operatorInstance.is(CommonFlags.Instance)){
-leftExpr=this.convertExpression(leftExpr,leftType,assert(signature.thisType),false,left);
-rightExpr=this.convertExpression(rightExpr,rightType,parameterTypes[0],false,right);
+firstExpr=this.convertExpression(firstExpr,firstType,assert(signature.thisType),false,first);
+secondExpr=this.convertExpression(secondExpr,secondType,parameterTypes[0],false,second);
 }else{
-leftExpr=this.convertExpression(leftExpr,leftType,parameterTypes[0],false,left);
-rightExpr=this.convertExpression(rightExpr,rightType,parameterTypes[1],false,right);
+firstExpr=this.convertExpression(firstExpr,firstType,parameterTypes[0],false,first);
+secondExpr=this.convertExpression(secondExpr,secondType,parameterTypes[1],false,second);
 }
-returnthis.makeCallDirect(operatorInstance,[leftExpr,rightExpr],reportNode);
+returnthis.makeCallDirect(operatorInstance,[firstExpr,secondExpr],reportNode);
 }
 
 privatecompileAssignment(