Fixes How BinaryOperators work on Unions (#1400)

* Binary operators on Unions work better now

* Used same logic on unary operators as well

* Updated test to check result type of complex binrary operation

* Binary and Unary operators handle ObjectType - issue #1387

Author: markwpearce

src/bscPlugin/hover/HoverProcessor.spec.ts

@@ -829,16 +829,16 @@ describe('HoverProcessor', () => {
                     if deviceInfo.getClockFormat() = "24h" then
                         hour = stringUtil.pad(hour)
                         ' "22:01" | "01:01"
-                        return substitute("{0}:{1}", hour, minutes as string)
+                        return substitute("{0}:{1}", hour as string, minutes as string)
                     else
                         hour = hour mod 12
                         if hour = 0 then hour = 12
                         ' "10:01 AM" | "1:01 AM"
-                        return substitute("{0}:{1} {2}", hour, minutes as string, meridiem)
+                        return substitute("{0}:{1} {2}", hour.toStr(), minutes as string, meridiem)
                     end if
                 end function
             `);
-            const expectedHourHoverStr = `hour as dynamic`;
+            const expectedHourHoverStr = `hour as integer or string`;
 
             program.validate();
             expectZeroDiagnostics(program);

src/bscPlugin/validation/ScopeValidator.spec.ts

@@ -3487,6 +3487,18 @@ describe('ScopeValidator', () => {
                 DiagnosticMessages.operatorTypeMismatch('=', 'uninitialized', 'invalid').message
             ]);
         });
+
+        it('allows string comparisons with object', () => {
+            program.setFile<BrsFile>('source/main.brs', `
+                sub test(x as object)
+                    if x <> "test"
+                        print x
+                    end if
+                end sub
+            `);
+            program.validate();
+            expectZeroDiagnostics(program);
+        });
     });
 
     describe('memberAccessibilityMismatch', () => {

src/files/BrsFile.spec.ts

@@ -24,7 +24,7 @@ import { SymbolTypeFlag } from '../SymbolTypeFlag';
 import { ClassType, EnumType, FloatType, InterfaceType } from '../types';
 import type { StandardizedFileEntry } from 'roku-deploy';
 import * as fileUrl from 'file-url';
-import { isAALiteralExpression, isBlock } from '../astUtils/reflection';
+import { isAALiteralExpression, isBlock, isFunctionExpression } from '../astUtils/reflection';
 import type { AALiteralExpression } from '../parser/Expression';
 import { CallExpression, FunctionExpression, LiteralExpression } from '../parser/Expression';
 import { Logger } from '@rokucommunity/logger';
@@ -192,7 +192,7 @@ describe('BrsFile', () => {
     it('does not crazy during validation with unique binary operator', () => {
         //monitor the logging system, if we detect an error, this test fails
         const spy = sinon.spy(Logger.prototype, 'error');
-        program.setFile('source/main.bs', `
+        const file = program.setFile<BrsFile>('source/main.bs', `
             namespace date
                 function timeElapsedInDay()
                     time = 1
@@ -215,6 +215,14 @@ describe('BrsFile', () => {
         expect(
             spy.getCalls().map(x => (x.args?.[0] as string)?.toString()).filter(x => x?.includes('Error when calling plugin'))
         ).to.eql([]);
+
+        // Check the result type too
+        const sourceScope = program.getScopeByName('source');
+        sourceScope.linkSymbolTable();
+        const timeElapsedFunc = file.ast.findChild<FunctionExpression>(isFunctionExpression);
+        const symbolTable = timeElapsedFunc.body.getSymbolTable();
+        const offsetType = symbolTable.getSymbolType('offset', { flags: SymbolTypeFlag.runtime });
+        expectTypeToBe(offsetType, IntegerType);
     });
 
     it('supports the third parameter in CreateObject', () => {

src/types/BscType.ts

@@ -139,4 +139,11 @@ export abstract class BscType {
         }
         this.hasAddedBuiltInInterfaces = true;
     }
+
+    /**
+     * The level of priority of this type when in a binary operation
+     * For example Float is higher priority than integer, so Float + Int => Float
+     * Lower numbers have higher priority
+     */
+    readonly binaryOpPriorityLevel: number = 0;
 }

src/types/DoubleType.ts

@@ -41,6 +41,8 @@ export class DoubleType extends BscType {
     public isEqual(targetType: BscType): boolean {
         return isDoubleType(targetType);
     }
+
+    readonly binaryOpPriorityLevel = 1;
 }
 
 BuiltInInterfaceAdder.primitiveTypeInstanceCache.set('double', DoubleType.instance);

src/types/DynamicType.ts

@@ -50,6 +50,8 @@ export class DynamicType extends BscType {
     getMemberType(memberName: string, options: GetTypeOptions) {
         return DynamicType.instance;
     }
+
+
 }
 
 BuiltInInterfaceAdder.primitiveTypeInstanceCache.set('dynamic', DynamicType.instance);

src/types/FloatType.ts

@@ -42,6 +42,8 @@ export class FloatType extends BscType {
     public isEqual(targetType: BscType): boolean {
         return isFloatType(targetType);
     }
+
+    readonly binaryOpPriorityLevel = 2;
 }
 
 BuiltInInterfaceAdder.primitiveTypeInstanceCache.set('float', FloatType.instance);

src/types/IntegerType.ts

@@ -41,6 +41,8 @@ export class IntegerType extends BscType {
     isEqual(otherType: BscType) {
         return isIntegerType(otherType);
     }
+
+    readonly binaryOpPriorityLevel = 4;
 }
 
 BuiltInInterfaceAdder.primitiveTypeInstanceCache.set('integer', IntegerType.instance);

src/types/LongIntegerType.ts

@@ -41,6 +41,8 @@ export class LongIntegerType extends BscType {
     isEqual(targetType: BscType): boolean {
         return isLongIntegerType(targetType);
     }
+
+    readonly binaryOpPriorityLevel = 3;
 }
 
 BuiltInInterfaceAdder.primitiveTypeInstanceCache.set('longinteger', LongIntegerType.instance);

src/types/UnionType.ts

@@ -64,7 +64,7 @@ export class UnionType extends BscType {
     }
 
     isTypeCompatible(targetType: BscType, data?: TypeCompatibilityData): boolean {
-        if (isDynamicType(targetType) || isObjectType(targetType)) {
+        if (isDynamicType(targetType) || isObjectType(targetType) || this === targetType) {
             return true;
         }
         if (isEnumTypeCompatible(this, targetType, data)) {
@@ -86,7 +86,6 @@ export class UnionType extends BscType {
             }
         }
 
-
         return false;
     }
     toString(): string {
@@ -106,6 +105,9 @@ export class UnionType extends BscType {
         if (!isUnionType(targetType)) {
             return false;
         }
+        if (this === targetType) {
+            return true;
+        }
         return this.isTypeCompatible(targetType) && targetType.isTypeCompatible(this);
     }