brighterscript 0.66.0-alpha.6 → 0.66.0-alpha.8

package/dist/bscPlugin/validation/ScopeValidator.spec.js

@@ -7,6 +7,7 @@ const testHelpers_spec_1 = require("../../testHelpers.spec");
 const chai_1 = require("chai");
 const IntegerType_1 = require("../../types/IntegerType");
 const StringType_1 = require("../../types/StringType");
+const types_1 = require("../../types");
 describe('ScopeValidator', () => {
     let sinon = sinonImport.createSandbox();
     let rootDir = process.cwd();
@@ -130,6 +131,57 @@ describe('ScopeValidator', () => {
             //should have no errors
             (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
         });
+        it('checks for at least the number of non-optional args on variadic (callFunc) functions', () => {
+            program.setFile('components/Widget.xml', (0, testHelpers_spec_1.trim) `
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.brs"/>
+                    <interface>
+                        <function name="someFunc" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/Widget.brs', `
+                sub someFunc(input as object)
+                    print input
+                end sub
+            `);
+            program.setFile('source/util.brs', `
+                sub useCallFunc(input as roSGNodeWidget)
+                    input.callFunc()
+                end sub
+            `);
+            program.validate();
+            //should have an error
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.mismatchArgumentCount('1-32', 0)
+            ]);
+        });
+        it('any number number of args on variadic (callFunc) functions', () => {
+            program.setFile('components/Widget.xml', (0, testHelpers_spec_1.trim) `
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.brs"/>
+                    <interface>
+                        <function name="someFunc" />
+                    </interface>
+                </component>
+            `);
+            program.setFile('components/Widget.brs', `
+                sub someFunc(input as object)
+                    print input
+                end sub
+            `);
+            program.setFile('source/util.brs', `
+                sub useCallFunc(input as roSGNodeWidget)
+                    input.callFunc("someFunc", 1, 2, 3, {})
+                end sub
+            `);
+            program.validate();
+            //TODO: do a better job of handling callFunc() invocations!
+            //should have an error
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
     });
     describe('argumentTypeMismatch', () => {
         it('param `as object` supports all known types', () => {
@@ -948,6 +1000,318 @@ describe('ScopeValidator', () => {
             (0, testHelpers_spec_1.expectTypeToBe)(data.fieldMismatches[0].expectedType, IntegerType_1.IntegerType);
             (0, testHelpers_spec_1.expectTypeToBe)(data.fieldMismatches[0].actualType, StringType_1.StringType);
         });
+        it('allows interfaces that have a superset of properties', () => {
+            program.setFile('source/util.bs', `
+                sub doStuff()
+                    takesMyIface({alpha: true, beta: "hello", charlie: 1})
+                end sub
+
+                sub takesMyIface(iFace as MyIFace)
+                end sub
+
+                interface MyIFace
+                    beta as string
+                    charlie as integer
+                end interface
+            `);
+            program.validate();
+            //should have no errors
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('allows interfaces that have a superset of properties', () => {
+            program.setFile('source/util.bs', `
+                sub doStuff(otherFace as MyOtherFace)
+                    takesMyIface(otherFace)
+                end sub
+
+                sub takesMyIface(iFace as MyIFace)
+                end sub
+
+                interface MyIFace
+                    beta as string
+                    charlie as integer
+                end interface
+
+                interface MyOtherFace
+                    alpha as boolean
+                    beta as string
+                    charlie as integer
+                end interface
+            `);
+            program.validate();
+            //should have no errors
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('includes data on missing fields', () => {
+            program.setFile('source/util.bs', `
+                sub doStuff()
+                    takesMyIface({charlie: "hello"})
+                end sub
+
+                sub takesMyIface(iFace as MyIFace)
+                end sub
+
+                interface MyIFace
+                    beta as string
+                    charlie as integer
+                end interface
+            `);
+            program.validate();
+            //should have error
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch('roAssociativeArray', 'MyIFace', {
+                    missingFields: [{ name: 'beta', expectedType: StringType_1.StringType.instance }],
+                    fieldMismatches: [{ name: 'charlie', expectedType: IntegerType_1.IntegerType.instance, actualType: StringType_1.StringType.instance }]
+                }).message
+            ]);
+            //The aa should have 'beta' and 'charlie' properties of type string and integer
+            const diagnostics = program.getDiagnostics();
+            (0, chai_1.expect)(diagnostics.length).to.eq(1);
+            const data = diagnostics[0].data;
+            (0, chai_1.expect)(data.missingFields.length).to.eq(1);
+            (0, chai_1.expect)(data.missingFields[0].name).to.eq('beta');
+            (0, testHelpers_spec_1.expectTypeToBe)(data.missingFields[0].expectedType, StringType_1.StringType);
+            (0, chai_1.expect)(data.fieldMismatches.length).to.eq(1);
+            (0, chai_1.expect)(data.fieldMismatches[0].name).to.eq('charlie');
+            (0, testHelpers_spec_1.expectTypeToBe)(data.fieldMismatches[0].expectedType, IntegerType_1.IntegerType);
+            (0, testHelpers_spec_1.expectTypeToBe)(data.fieldMismatches[0].actualType, StringType_1.StringType);
+        });
+        describe('array compatibility', () => {
+            it('accepts dynamic when assigning to a roArray', () => {
+                program.setFile('source/util.bs', `
+                    sub takesArray(arr as roArray)
+                    end sub
+
+                    sub doStuff(someArray)
+                        takesArray(someArray)
+                    end sub
+                `);
+                program.validate();
+                //should have no errors
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            });
+            it('accepts roArray when assigning to a roArray', () => {
+                program.setFile('source/util.bs', `
+                    sub takesArray(arr as roArray)
+                    end sub
+
+                    sub doStuff(someArray as roArray)
+                        takesArray(someArray)
+                    end sub
+                `);
+                program.validate();
+                //should have no errors
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            });
+            it('accepts typed arrays when assigning to a roArray', () => {
+                program.setFile('source/util.bs', `
+                    sub takesArray(arr as roArray)
+                    end sub
+
+                    sub doStuff(someArray as dynamic[])
+                        takesArray(someArray)
+                    end sub
+                `);
+                program.validate();
+                //should have no errors
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            });
+            it('accepts roArray when assigning to dynamic[]', () => {
+                program.setFile('source/util.bs', `
+                    sub takesArray(arr as dynamic[])
+                    end sub
+
+                    sub doStuff(someArray as roArray)
+                        takesArray(someArray)
+                    end sub
+                `);
+                program.validate();
+                //should have no errors
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            });
+            it('accepts roArray when assigning to typed array', () => {
+                program.setFile('source/util.bs', `
+                    sub takesArray(arr as string[])
+                    end sub
+
+                    sub doStuff(someArray as roArray)
+                        takesArray(someArray)
+                    end sub
+                `);
+                program.validate();
+                //should have no errors
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            });
+            it('validates when typed array types are incompatible', () => {
+                program.setFile('source/util.bs', `
+                    sub takesArray(arr as string[])
+                    end sub
+
+                    sub doStuff(someArray as integer[])
+                        takesArray(someArray)
+                    end sub
+                `);
+                program.validate();
+                //should have errors
+                (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                    DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch('Array<integer>', 'Array<string>').message
+                ]);
+            });
+            it('accepts when typed array types are compatible', () => {
+                program.setFile('source/util.bs', `
+                    sub takesArray(arr as float[])
+                    end sub
+
+                    sub doStuff(someArray as integer[])
+                        takesArray(someArray)
+                    end sub
+                `);
+                program.validate();
+                //should have no errors
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            });
+        });
+        describe('interface with optional properties', () => {
+            it('allows using interfaces with optional props', () => {
+                program.setFile('source/util.bs', `
+                    function takesIFace(iface as MyIFace) as string
+                        if invalid <> iface.name
+                            return iface.name
+                        else if invalid <> iface.data
+                            return FormatJson(iface.data)
+                        end if
+                        return "no"
+                    end function
+
+                    sub doStuff(iface as MyIFace)
+                        print takesIFace(iface)
+                    end sub
+
+                    interface MyIFace
+                        optional name as string
+                        optional data
+                    end interface
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            });
+            it('allows using passing AAs with missing optional properties', () => {
+                program.setFile('source/util.bs', `
+                    function takesIFace(iface as MyIFace) as string
+                        if invalid <> iface.name
+                            return iface.name
+                        else if invalid <> iface.data
+                            return FormatJson(iface.data)
+                        end if
+                        return "no"
+                    end function
+
+                    sub doStuff(iface as MyIFace)
+                        print takesIFace({name: "Hello"})
+                    end sub
+
+                    interface MyIFace
+                        optional name as string
+                        optional data
+                    end interface
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            });
+            it('disallows using AAs with bad types for optional properties', () => {
+                program.setFile('source/util.bs', `
+                    function takesIFace(iface as MyIFace) as string
+                        if invalid <> iface.name
+                            return iface.name
+                        else if invalid <> iface.data
+                            return FormatJson(iface.data)
+                        end if
+                        return "no"
+                    end function
+
+                    sub doStuff(iface as MyIFace)
+                        print takesIFace({name: 3.14})
+                    end sub
+
+                    interface MyIFace
+                        optional name as string
+                        optional data
+                    end interface
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                    DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch('roAssociativeArray', 'MyIFace', {
+                        fieldMismatches: [{ name: 'name', expectedType: StringType_1.StringType.instance, actualType: types_1.FloatType.instance }]
+                    }).message
+                ]);
+            });
+            it('disallows passing classes with bad types for optional properties', () => {
+                program.setFile('source/util.bs', `
+                    function takesIFace(iface as MyIFace) as string
+                        if invalid <> iface.name
+                            return iface.name
+                        else if invalid <> iface.data
+                            return FormatJson(iface.data)
+                        end if
+                        return "no"
+                    end function
+
+                    sub doStuff(iface as MyIFace)
+                        k = new MyKlass()
+                        print takesIFace(k)
+                    end sub
+
+                    interface MyIFace
+                        optional name as string
+                        optional data
+                    end interface
+
+                    class MyKlass
+                        name as float
+                    end class
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                    DiagnosticMessages_1.DiagnosticMessages.argumentTypeMismatch('MyKlass', 'MyIFace', {
+                        fieldMismatches: [{ name: 'name', expectedType: StringType_1.StringType.instance, actualType: types_1.FloatType.instance }]
+                    }).message
+                ]);
+            });
+            it('allows passing classes as args for interfaces with optional properties', () => {
+                program.setFile('source/util.bs', `
+                    function takesIFace(iface as MyIFace) as string
+                        if invalid <> iface.name
+                            return iface.name
+                        else if invalid <> iface.data
+                            return FormatJson(iface.data)
+                        end if
+                        return "no"
+                    end function
+
+                    sub doStuff(iface as MyIFace)
+                        k = new MyKlass()
+                        k2 = new MyKlass2()
+                        print takesIFace(k)
+                        print takesIFace(k2)
+                    end sub
+
+                    interface MyIFace
+                        optional name as string
+                        optional data
+                    end interface
+
+                    class MyKlass
+                        data = {}
+                    end class
+
+                    class MyKlass2
+                        data = "test"
+                    end class
+                `);
+                program.validate();
+                (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            });
+        });
     });
     describe('cannotFindName', () => {
         it('finds variables from assignments from member functions of primitive types', () => {
@@ -973,6 +1337,21 @@ describe('ScopeValidator', () => {
                 DiagnosticMessages_1.DiagnosticMessages.cannotFindName('expected').message
             ]);
         });
+        it('does not have a diagnostic for using a variable the result of an assignment with unresolved value', () => {
+            program.setFile('source/util.bs', `
+                sub doStuff()
+                    myValue = UndeclaredValue
+                    if myValue > 0
+                        print "hello"
+                    end if
+                end sub
+            `);
+            program.validate();
+            //should have only 1 error - cannot find "UndeclaredValue"
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.cannotFindName('UndeclaredValue').message
+            ]);
+        });
     });
     describe('returnTypeMismatch', () => {
         it('finds when a function returns a type that is not what was declared', () => {
@@ -1062,6 +1441,110 @@ describe('ScopeValidator', () => {
                 DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('string', 'void').message
             ]);
         });
+        it('allows returning enums with the default type that matches the declared return type', () => {
+            program.setFile('source/util.bs', `
+                enum MyEnum
+                    val1
+                    val2
+                end enum
+
+                function getInt() as integer
+                    return MyEnum.val1
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('allows returning enums passed as a param with the default type that matches the declared return type', () => {
+            program.setFile('source/util.bs', `
+                enum MyEnum
+                    val1
+                    val2
+                end enum
+
+                function getInt(enumVal as MyEnum) as integer
+                    return enumVal
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('allows returning enums with the default type that matches the declared return type for string enums', () => {
+            program.setFile('source/util.bs', `
+                enum MyEnum
+                    val1 = "hello"
+                    val2 = "world"
+                end enum
+
+                function getInt() as string
+                    return MyEnum.val1
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
+        it('flags returning enums with the default type that does not matches the declared return type', () => {
+            program.setFile('source/util.bs', `
+                enum MyEnum
+                    val1 = "hello"
+                    val2 = "world"
+                end enum
+
+                function getInt() as integer
+                    return MyEnum.val1
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('MyEnum', 'integer').message
+            ]);
+        });
+        it('flags returning enums passed as params with the default type that does not matches the declared return type', () => {
+            program.setFile('source/util.bs', `
+                enum MyEnum
+                    val1 = "hello"
+                    val2 = "world"
+                end enum
+
+                function getInt(enumVal as MyEnum) as integer
+                    return enumVal
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnostics)(program, [
+                DiagnosticMessages_1.DiagnosticMessages.returnTypeMismatch('MyEnum', 'integer').message
+            ]);
+        });
+        it('flags returning enums type', () => {
+            program.setFile('source/util.bs', `
+                enum MyEnum
+                    val1 = "hello"
+                    val2 = "world"
+                end enum
+
+
+                function getInt() as integer
+                    return MyEnum
+                end function
+            `);
+            program.validate();
+            (0, chai_1.expect)(program.getDiagnostics().length).to.be.greaterThan(0);
+        });
+        it('allows returning an Enum', () => {
+            program.setFile('source/util.bs', `
+                enum MyEnum
+                    val1 = "hello"
+                    val2 = "world"
+                end enum
+
+
+                function getInt() as MyEnum
+                    return MyEnum.val1
+                end function
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+        });
     });
     describe('assignmentTypeMismatch', () => {
         it('finds when the type of the lhs is not compatible with the expected type', () => {
@@ -1331,5 +1814,191 @@ describe('ScopeValidator', () => {
             (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
         });
     });
+    describe('revalidation', () => {
+        it('revalidates when a enum defined in a different namespace changes', () => {
+            program.setFile('source/file1.bs', `
+                namespace Alpha
+                    function printEnum(enumVal as Alpha.Beta.Charlie.SomeEnum) as string
+                        return enumVal.toStr()
+                    end function
+                end namespace
+            `);
+            program.setFile('source/file2.bs', `
+                namespace Alpha.Beta.Charlie
+                    enum SomeEnum
+                        val1 = 1
+                        val2 = 2
+                    end enum
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            program.setFile('source/file2.bs', `
+                namespace Alpha.Beta.Charlie
+                    enum ChangedEnum
+                        val1 = 1
+                        val2 = 2
+                    end enum
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(program, [DiagnosticMessages_1.DiagnosticMessages.cannotFindName('SomeEnum').message]);
+        });
+        it('revalidates when a class defined in a different namespace changes', () => {
+            program.setFile('source/file1.bs', `
+                namespace Alpha
+                    function printEnum(myKlass as Alpha.Beta.Charlie.SomeClass) as string
+                        return myKlass.getValue()
+                    end function
+                end namespace
+            `);
+            program.setFile('source/file2.bs', `
+                namespace Alpha.Beta.Charlie
+                    class SomeClass
+                        private myValue as string
+                        function getValue() as string
+                            return m.myValue
+                        end function
+                    end class
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            program.setFile('source/file2.bs', `
+                namespace Alpha.Beta.Charlie
+                    class SomeClass
+                        private myValue as string
+                        function getValue(lowerCase as boolean) as string
+                            if lowerCase
+                                return lcase(m.myValue)
+                            end if
+                            return m.myValue
+                        end function
+                    end class
+                end namespace
+            `);
+            program.validate();
+            (0, testHelpers_spec_1.expectDiagnosticsIncludes)(program, [DiagnosticMessages_1.DiagnosticMessages.mismatchArgumentCount(1, 0).message]);
+        });
+        it('validates only parts of files that need revalidation on scope validation', () => {
+            function validateFile(file) {
+                const validateFileEvent = {
+                    program: program,
+                    file: file
+                };
+                //emit an event to allow plugins to contribute to the file validation process
+                program.plugins.emit('onFileValidate', validateFileEvent);
+            }
+            const commonContents = `
+                sub noValidationForEachScope()
+                    k = new KlassInSameFile()
+                    print k.value
+                end sub
+
+                class KlassInSameFile
+                    value = 1
+                end class
+            `;
+            let commonBs = program.setFile('source/common.bs', commonContents);
+            validateFile(commonBs);
+            (0, chai_1.expect)(commonBs.validationSegmenter.segmentsForValidation.length).to.eq(2); // 1 func,  1 classField
+            (0, chai_1.expect)(commonBs.validationSegmenter.unresolvedSegmentsSymbols.size).to.eq(0);
+            commonBs.validationSegmenter.validatedSegments.forEach(x => (0, chai_1.expect)(x).to.be.false);
+            (0, chai_1.expect)(commonBs.validationSegmenter.singleValidationSegments.size).to.eq(2); // no references needed to other files
+            let common2Contents = `
+                sub doesValidationForEachScope()
+                    k = new KlassInDiffFile()
+                    print k.value
+                end sub
+
+                function alsoNoValidationForEachScope() as integer
+                    return 1
+                end function
+            `;
+            let common2Bs = program.setFile('source/common2.bs', common2Contents);
+            validateFile(common2Bs);
+            (0, chai_1.expect)(common2Bs.validationSegmenter.segmentsForValidation.length).to.eq(2); // 2 func
+            (0, chai_1.expect)(common2Bs.validationSegmenter.unresolvedSegmentsSymbols.size).to.eq(1);
+            commonBs.validationSegmenter.validatedSegments.forEach(x => (0, chai_1.expect)(x).to.be.false);
+            (0, chai_1.expect)(common2Bs.validationSegmenter.singleValidationSegments.size).to.eq(1); // alsoNoValidationForEachScope() does not reference other files
+            let klassContents = `
+                class KlassInDiffFile
+                    value = 2
+                end class
+            `;
+            let klassBs = program.setFile('source/klass.bs', klassContents);
+            validateFile(klassBs);
+            (0, chai_1.expect)(klassBs.validationSegmenter.segmentsForValidation.length).to.eq(1); //  1 classField
+            (0, chai_1.expect)(klassBs.validationSegmenter.unresolvedSegmentsSymbols.size).to.eq(0);
+            klassBs.validationSegmenter.validatedSegments.forEach(x => (0, chai_1.expect)(x).to.be.false);
+            (0, chai_1.expect)(klassBs.validationSegmenter.singleValidationSegments.size).to.eq(1); // does not reference other files
+            const widgetFileContents = `
+                sub init()
+                    noValidationForEachScope()
+                    doesValidationForEachScope()
+                end sub
+
+                sub anotherFunction()
+                    print "hello"
+                end sub
+            `;
+            let widgetBs = program.setFile('components/Widget.bs', widgetFileContents);
+            validateFile(widgetBs);
+            (0, chai_1.expect)(widgetBs.validationSegmenter.segmentsForValidation.length).to.eq(2); // 2 funcs
+            (0, chai_1.expect)(widgetBs.validationSegmenter.unresolvedSegmentsSymbols.size).to.eq(1); // 1 func (init)
+            widgetBs.validationSegmenter.validatedSegments.forEach(x => (0, chai_1.expect)(x).to.be.false);
+            (0, chai_1.expect)(widgetBs.validationSegmenter.singleValidationSegments.size).to.eq(1); // 1 func (anotherFunction)
+            const diffKlassContent = `
+                class KlassInDiffFile
+                    value = 3
+                end class
+            `;
+            let diffKlassBs = program.setFile('components/diffKlass.bs', diffKlassContent);
+            validateFile(diffKlassBs);
+            (0, chai_1.expect)(diffKlassBs.validationSegmenter.segmentsForValidation.length).to.eq(1); //  1 classField
+            (0, chai_1.expect)(diffKlassBs.validationSegmenter.unresolvedSegmentsSymbols.size).to.eq(0);
+            diffKlassBs.validationSegmenter.validatedSegments.forEach(x => (0, chai_1.expect)(x).to.be.false);
+            (0, chai_1.expect)(diffKlassBs.validationSegmenter.singleValidationSegments.size).to.eq(1);
+            program.setFile('components/Widget.xml', (0, testHelpers_spec_1.trim) `
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="Widget" extends="Group">
+                    <script uri="Widget.bs"/>
+                    <script uri="pkg:/source/common.bs"/>
+                    <script uri="pkg:/source/common2.bs"/>
+                    <script uri="diffKlass.bs"/>
+                </component>
+            `);
+            //reset files
+            commonBs = program.setFile('source/common.bs', commonContents);
+            common2Bs = program.setFile('source/common2.bs', common2Contents);
+            klassBs = program.setFile('source/klass.bs', klassContents);
+            widgetBs = program.setFile('components/Widget.bs', widgetFileContents);
+            diffKlassBs = program.setFile('components/diffKlass.bs', diffKlassContent);
+            program.validate();
+            // all segments should be validated
+            [commonBs, common2Bs, klassBs, widgetBs, diffKlassBs].forEach(file => {
+                (0, chai_1.expect)(file.validationSegmenter.validatedSegments.size).to.gte(file.validationSegmenter.segmentsForValidation.length);
+                file.validationSegmenter.validatedSegments.forEach(x => (0, chai_1.expect)(x).to.be.true);
+            });
+            (0, testHelpers_spec_1.expectZeroDiagnostics)(program);
+            program.setFile('components/Widget.bs', widgetFileContents);
+            program.validate();
+            // Widget.bs has changed. it needs to totally re-validated
+            // and other files in the scope need to revalidate only the unresolved segments - should be source/common2.bs
+            // TODO: how to test this?
+            program.validate();
+            program.setFile('components/diffKlass.bs', diffKlassContent);
+            // diffKlass.bs has changed. it needs to totally re-validated
+            // no other files in scope reference it .. no other files need revalidation
+            // TODO: how to test this?
+            program.validate();
+            program.setFile('source/common.bs', commonContents);
+            // common.bs has changed. it needs to totally re-validated
+            // in source scope, common2.bs still has unresolves, it needs revalidation
+            // in widget scope, widget.bs references it
+            // TODO: how to test this?
+            program.validate();
+        });
+    });
 });
 //# sourceMappingURL=ScopeValidator.spec.js.map