Semantic Tokes for Native Components and Type completion in Type Expressions

src/astUtils/reflection.ts

@@ -366,17 +366,25 @@ export function isNumberType(value: any): value is IntegerType | LongIntegerType
 }
 
 const primitiveTypeKinds = [
-    BscTypeKind.IntegerType,
-    BscTypeKind.LongIntegerType,
-    BscTypeKind.FloatType,
-    BscTypeKind.DoubleType,
+    ...numberTypeKinds,
     BscTypeKind.BooleanType,
     BscTypeKind.StringType
 ];
 export function isPrimitiveType(value: any): value is IntegerType | LongIntegerType | FloatType | DoubleType | StringType | BooleanType {
     return primitiveTypeKinds.includes(value?.kind);
 }
 
+const nativeTypeKinds = [
+    ...primitiveTypeKinds,
+    BscTypeKind.DynamicType,
+    BscTypeKind.ObjectType,
+    BscTypeKind.VoidType,
+    BscTypeKind.FunctionType
+];
+export function isNativeType(value: any): value is IntegerType | LongIntegerType | FloatType | DoubleType | StringType | BooleanType | VoidType | DynamicType | ObjectType | FunctionType {
+    return nativeTypeKinds.includes(value?.kind);
+}
+
 
 // Literal reflection
 

src/bscPlugin/completions/CompletionsProcessor.spec.ts

@@ -1595,4 +1595,66 @@ describe('CompletionsProcessor', () => {
         });
     });
 
+    describe('type expressions', () => {
+        it('finds built in types', () => {
+            program.setFile('source/main.bs', `
+                sub foo(thing as  )
+                    print thing
+                end sub
+            `);
+            program.validate();
+            //  sub foo(thing as | )
+            const completions = program.getCompletions('source/main.bs', util.createPosition(1, 34));
+            expectCompletionsIncludes(completions, [{
+                label: 'integer',
+                kind: CompletionItemKind.Keyword
+            }]);
+            expectCompletionsIncludes(completions, [{
+                label: 'roSGNode',
+                kind: CompletionItemKind.Interface
+            }]);
+        });
+
+        it('finds custom types', () => {
+            program.setFile('source/main.bs', `
+                sub foo(thing as  )
+                    print thing
+                end sub
+
+                class SomeKlass
+                end class
+            `);
+            program.validate();
+            //  sub foo(thing as | )
+            const completions = program.getCompletions('source/main.bs', util.createPosition(1, 34));
+            expectCompletionsIncludes(completions, [{
+                label: 'SomeKlass',
+                kind: CompletionItemKind.Class
+            }]);
+        });
+
+        it('only shows intrinsic/native types in brightscript', () => {
+            program.setFile('source/main.brs', `
+                sub foo(thing as  )
+                    print thing
+                end sub
+            `);
+            program.validate();
+            //  sub foo(thing as | )
+            const completions = program.getCompletions('source/main.brs', util.createPosition(1, 34));
+            expectCompletionsIncludes(completions, [{
+                label: 'integer',
+                kind: CompletionItemKind.Keyword
+            }]);
+            expectCompletionsIncludes(completions, [{
+                label: 'function',
+                kind: CompletionItemKind.Keyword
+            }]);
+            expectCompletionsExcludes(completions, [{
+                label: 'roSGNode'
+            }]);
+        });
+
+    });
+
 });

src/bscPlugin/completions/CompletionsProcessor.ts

@@ -1,6 +1,6 @@
-import { isBrsFile, isCallableType, isClassType, isComponentType, isConstStatement, isEnumMemberType, isEnumType, isInterfaceType, isMethodStatement, isNamespaceType, isXmlFile, isXmlScope } from '../../astUtils/reflection';
+import { isBrsFile, isCallableType, isClassType, isComponentType, isConstStatement, isEnumMemberType, isEnumType, isInterfaceType, isMethodStatement, isNamespaceType, isNativeType, isXmlFile, isXmlScope } from '../../astUtils/reflection';
 import type { BscFile, ExtraSymbolData, FileReference, ProvideCompletionsEvent } from '../../interfaces';
-import { Keywords, TokenKind } from '../../lexer/TokenKind';
+import { DeclarableTypes, Keywords, TokenKind } from '../../lexer/TokenKind';
 import type { XmlScope } from '../../XmlScope';
 import { util } from '../../util';
 import type { Scope } from '../../Scope';
@@ -156,6 +156,7 @@ export class CompletionsProcessor {
         let expression: AstNode;
         let shouldLookForMembers = false;
         let shouldLookForCallFuncMembers = false;
+        let symbolTableLookupFlag = SymbolTypeFlag.runtime;
 
         if (file.tokenFollows(currentToken, TokenKind.Goto)) {
             let functionScope = file.getFunctionScopeAtPosition(position);
@@ -173,6 +174,13 @@ export class CompletionsProcessor {
             const beforeDotToken = file.getTokenBefore(dotToken);
             expression = file.getClosestExpression(beforeDotToken?.range.end);
             shouldLookForCallFuncMembers = true;
+        } else if (file.getPreviousToken(currentToken)?.kind === TokenKind.As || file.isTokenNextToTokenKind(currentToken, TokenKind.As)) {
+
+            if (file.parseMode === ParseMode.BrightScript) {
+                return NativeTypeCompletions;
+            }
+            expression = file.getClosestExpression(this.event.position);
+            symbolTableLookupFlag = SymbolTypeFlag.typetime;
         } else {
             expression = file.getClosestExpression(this.event.position);
         }
@@ -212,7 +220,7 @@ export class CompletionsProcessor {
 
         for (const scope of this.event.scopes) {
             scope.linkSymbolTable();
-            let currentSymbols = getSymbolTableForLookups()?.getAllSymbols(SymbolTypeFlag.runtime) ?? [];
+            let currentSymbols = getSymbolTableForLookups()?.getAllSymbols(symbolTableLookupFlag) ?? [];
             // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
             switch (tokenBefore.kind) {
                 case TokenKind.New:
@@ -279,6 +287,8 @@ export class CompletionsProcessor {
             return CompletionItemKind.EnumMember;
         } else if (isNamespaceType(type)) {
             return CompletionItemKind.Module;
+        } else if (isNativeType(type)) {
+            return CompletionItemKind.Keyword;
         }
         return areMembers ? CompletionItemKind.Field : CompletionItemKind.Variable;
     }
@@ -409,7 +419,6 @@ export class CompletionsProcessor {
         //no other result is possible in this case
         return completionsArray;
     }
-
 }
 
 /**
@@ -426,3 +435,17 @@ export const KeywordCompletions = Object.keys(Keywords)
             kind: CompletionItemKind.Keyword
         } as CompletionItem;
     });
+
+
+/**
+ * List of completions for all valid intrinsic types.
+ * Build this list once because it won't change for the lifetime of this process
+ */
+export const NativeTypeCompletions = DeclarableTypes
+    //create completions
+    .map(x => {
+        return {
+            label: x.toLowerCase(),
+            kind: CompletionItemKind.Keyword
+        } as CompletionItem;
+    });

src/bscPlugin/semanticTokens/BrsFileSemanticTokensProcessor.spec.ts

@@ -421,4 +421,29 @@ describe('BrsFileSemanticTokensProcessor', () => {
             }
         ]);
     });
+
+
+    it('matches native interfaces', () => {
+        const file = program.setFile<BrsFile>('source/main.bs', `
+            sub init()
+                m.alien = new Humanoids.Aliens.Alien.NOT_A_CLASS() 'bs:disable-line
+            end sub
+
+            namespace Humanoids.Aliens
+                class Alien
+                end class
+            end namespace
+        `);
+        expectSemanticTokens(file, [{
+            range: util.createRange(2, 30, 2, 39),
+            tokenType: SemanticTokenTypes.namespace
+        }, {
+            range: util.createRange(2, 40, 2, 46),
+            tokenType: SemanticTokenTypes.namespace
+        }, {
+            range: util.createRange(2, 47, 2, 52),
+            tokenType: SemanticTokenTypes.class
+        }]);
+    });
+
 });

src/bscPlugin/semanticTokens/BrsFileSemanticTokensProcessor.ts

@@ -1,14 +1,15 @@
 import type { Range } from 'vscode-languageserver-protocol';
 import { SemanticTokenModifiers } from 'vscode-languageserver-protocol';
 import { SemanticTokenTypes } from 'vscode-languageserver-protocol';
-import { isCallExpression, isClassType, isNamespaceStatement, isNewExpression } from '../../astUtils/reflection';
+import { isCallExpression, isCallableType, isClassType, isComponentType, isConstStatement, isEnumMemberType, isEnumType, isInterfaceType, isNamespaceStatement, isNamespaceType, isNativeType, isNewExpression } from '../../astUtils/reflection';
 import type { BrsFile } from '../../files/BrsFile';
-import type { OnGetSemanticTokensEvent } from '../../interfaces';
+import type { ExtraSymbolData, OnGetSemanticTokensEvent } from '../../interfaces';
 import type { Locatable } from '../../lexer/Token';
 import { ParseMode } from '../../parser/Parser';
 import type { NamespaceStatement } from '../../parser/Statement';
 import util from '../../util';
 import { SymbolTypeFlag } from '../../SymbolTable';
+import type { BscType } from '../../types/BscType';
 
 export class BrsFileSemanticTokensProcessor {
     public constructor(
@@ -92,7 +93,7 @@ export class BrsFileSemanticTokensProcessor {
         if (!scope) {
             return;
         }
-
+        scope.linkSymbolTable();
         const nodes = [
             ...this.event.file.parser.references.expressions,
             //make a new VariableExpression to wrap the name. This is a hack, we could probably do it better
@@ -120,14 +121,47 @@ export class BrsFileSemanticTokensProcessor {
                     this.addToken(token, SemanticTokenTypes.enum);
                 } else if (scope.getClass(entityName, containingNamespaceNameLower)) {
                     this.addToken(token, SemanticTokenTypes.class);
+                } else if (scope.getInterface(entityName, containingNamespaceNameLower)) {
+                    this.addToken(token, SemanticTokenTypes.interface);
                 } else if (scope.getCallableByName(entityName)) {
                     this.addToken(token, SemanticTokenTypes.function);
                 } else if (scope.getNamespace(entityName, containingNamespaceNameLower)) {
                     this.addToken(token, SemanticTokenTypes.namespace);
                 } else if (scope.getConstFileLink(entityName, containingNamespaceNameLower)) {
                     this.addToken(token, SemanticTokenTypes.variable, [SemanticTokenModifiers.readonly, SemanticTokenModifiers.static]);
+                } else {
+                    const extraData = {};
+                    const symbolType = scope.symbolTable.getSymbolType(token.text, { flags: SymbolTypeFlag.typetime, data: extraData });
+                    if (symbolType?.isResolvable()) {
+                        this.addToken(token, this.getSemanticTokenTypeFromType(symbolType, extraData, !!containingNamespaceNameLower));
+                    }
                 }
             }
         }
+        scope.unlinkSymbolTable();
+    }
+
+    // TODO: We can use the actual symbol tables to find methods and member fields.
+    private getSemanticTokenTypeFromType(type: BscType, extraData: ExtraSymbolData, areMembers = false) {
+        if (isConstStatement(extraData?.definingNode)) {
+            return SemanticTokenTypes.variable;
+        } else if (isClassType(type)) {
+            return SemanticTokenTypes.class;
+        } else if (isCallableType(type)) {
+            return areMembers ? SemanticTokenTypes.method : SemanticTokenTypes.function;
+        } else if (isInterfaceType(type)) {
+            return SemanticTokenTypes.interface;
+        } else if (isComponentType(type)) {
+            return SemanticTokenTypes.class;
+        } else if (isEnumType(type)) {
+            return SemanticTokenTypes.enum;
+        } else if (isEnumMemberType(type)) {
+            return SemanticTokenTypes.enumMember;
+        } else if (isNamespaceType(type)) {
+            return SemanticTokenTypes.namespace;
+        } else if (isNativeType(type)) {
+            return SemanticTokenTypes.type;
+        }
+        return areMembers ? SemanticTokenTypes.property : SemanticTokenTypes.variable;
     }
 }

src/lexer/TokenKind.ts

@@ -610,7 +610,6 @@ export const DeclarableTypes = [
     TokenKind.Double,
     TokenKind.String,
     TokenKind.Object,
-    TokenKind.Interface,
     TokenKind.Dynamic,
     TokenKind.Void,
     TokenKind.Function

src/parser/Parser.spec.ts

@@ -714,6 +714,16 @@ describe('parser', () => {
                 expect(stmt.expression.obj.name.text).to.equal('a');
                 expect(stmt.expression.name.text).to.equal('b');
             });
+
+            it('adds function statement with missing type after as', () => {
+                let parser = parse(`
+                    sub foo(thing as  )
+                        print thing
+                    end sub
+                `, ParseMode.BrighterScript);
+                expect(parser.diagnostics[0]?.message).to.exist;
+                expect(parser.ast.statements[0]).to.be.instanceof(FunctionStatement);
+            });
         });
 
         describe('comments', () => {

src/parser/Parser.ts

@@ -412,6 +412,11 @@ export class Parser {
                 });
                 //consume the statement separator
                 this.consumeStatementSeparators();
+            } else if (this.peek().kind !== TokenKind.Identifier && !this.checkAny(...DeclarableTypes, ...AllowedTypeIdentifiers)) {
+                this.diagnostics.push({
+                    ...DiagnosticMessages.expectedIdentifierAfterKeyword(asToken.text),
+                    range: asToken.range
+                });
             } else {
                 typeExpression = this.typeExpression();
             }