diff --git a/docs/plugins.md b/docs/plugins.md
index a84e3fe85..f94fbabbf 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -93,11 +93,7 @@ After file addition/removal (note: throttled/debounced):
 - `afterProgramValidate`
 
 Code Actions
- - `beforeProgramGetCodeActions`
- - `onFileGetCodeActions`
- - for each scope that includes the file
-    - `onScopeGetCodeActions`
- - `afterProgramGetCodeActions`
+ - `onProgramGetCodeActions`
 
 ## Compiler API
 
diff --git a/src/DiagnosticMessages.ts b/src/DiagnosticMessages.ts
index 5e075a822..448bee61a 100644
--- a/src/DiagnosticMessages.ts
+++ b/src/DiagnosticMessages.ts
@@ -1,7 +1,6 @@
-/* eslint-disable camelcase */
-
 import type { Position } from 'vscode-languageserver';
 import { DiagnosticSeverity } from 'vscode-languageserver';
+import type { BsDiagnostic } from './interfaces';
 import type { TokenKind } from './lexer/TokenKind';
 
 /**
@@ -644,4 +643,7 @@ export interface DiagnosticInfo {
  * The second type parameter is optional, but allows plugins to pass in their own
  * DiagnosticMessages-like object in order to get the same type support
  */
-export type DiagnosticMessageType<K extends keyof D, D extends Record<string, (...args: any) => any> = typeof DiagnosticMessages> = ReturnType<D[K]>;
+export type DiagnosticMessageType<K extends keyof D, D extends Record<string, (...args: any) => any> = typeof DiagnosticMessages> =
+    ReturnType<D[K]> &
+    //include the missing properties from BsDiagnostic
+    Pick<BsDiagnostic, 'range' | 'file' | 'relatedInformation' | 'tags'>;
diff --git a/src/LanguageServer.ts b/src/LanguageServer.ts
index fc00c95f6..8074fc4e8 100644
--- a/src/LanguageServer.ts
+++ b/src/LanguageServer.ts
@@ -31,7 +31,6 @@ import {
 } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
 import { TextDocument } from 'vscode-languageserver-textdocument';
-
 import type { BsConfig } from './BsConfig';
 import { Deferred } from './deferred';
 import { DiagnosticMessages } from './DiagnosticMessages';
@@ -554,17 +553,23 @@ export class LanguageServer {
         //ensure programs are initialized
         await this.waitAllProgramFirstRuns();
 
-        let filePath = util.uriToPath(params.textDocument.uri);
+        let srcPath = util.uriToPath(params.textDocument.uri);
 
         //wait until the file has settled
-        await this.keyedThrottler.onIdleOnce(filePath, true);
+        await this.keyedThrottler.onIdleOnce(srcPath, true);
 
-        let codeActions = this
+        const codeActions = this
             .getWorkspaces()
             //skip programs that don't have this file
-            .filter(x => x.builder.program.hasFile(filePath))
-            .flatMap(workspace => workspace.builder.program.getCodeActions(filePath, params.range));
+            .filter(x => x.builder?.program?.hasFile(srcPath))
+            .flatMap(workspace => workspace.builder.program.getCodeActions(srcPath, params.range));
 
+        //clone the diagnostics for each code action, since certain diagnostics can have circular reference properties that kill the language server if serialized
+        for (const codeAction of codeActions) {
+            if (codeAction.diagnostics) {
+                codeAction.diagnostics = codeAction.diagnostics.map(x => util.toDiagnostic(x));
+            }
+        }
         return codeActions;
     }
 
@@ -1051,16 +1056,7 @@ export class LanguageServer {
         const patch = await this.diagnosticCollection.getPatch(this.workspaces);
 
         for (let filePath in patch) {
-            const diagnostics = patch[filePath].map(d => {
-                return {
-                    severity: d.severity,
-                    range: d.range,
-                    message: d.message,
-                    relatedInformation: d.relatedInformation,
-                    code: d.code,
-                    source: 'brs'
-                };
-            });
+            const diagnostics = patch[filePath].map(d => util.toDiagnostic(d));
 
             this.connection.sendDiagnostics({
                 uri: URI.file(filePath).toString(),
diff --git a/src/Program.ts b/src/Program.ts
index ad67bc72e..cb3b621bf 100644
--- a/src/Program.ts
+++ b/src/Program.ts
@@ -783,23 +783,24 @@ export class Program {
         const codeActions = [] as CodeAction[];
         const file = this.getFile(pathAbsolute);
         if (file) {
+            const diagnostics = this
+                //get all current diagnostics (filtered by diagnostic filters)
+                .getDiagnostics()
+                //only keep diagnostics related to this file
+                .filter(x => x.file === file)
+                //only keep diagnostics that touch this range
+                .filter(x => util.rangesIntersect(x.range, range));
 
-            this.plugins.emit('beforeProgramGetCodeActions', this, file, range, codeActions);
-
-            //get code actions from the file
-            file.getCodeActions(range, codeActions);
-
-            //get code actions from every scope this file is a member of
-            for (let key in this.scopes) {
-                let scope = this.scopes[key];
-
-                if (scope.hasFile(file)) {
-                    //get code actions from each scope this file is a member of
-                    scope.getCodeActions(file, range, codeActions);
-                }
-            }
+            const scopes = this.getScopesForFile(file);
 
-            this.plugins.emit('afterProgramGetCodeActions', this, file, range, codeActions);
+            this.plugins.emit('onGetCodeActions', {
+                program: this,
+                file: file,
+                range: range,
+                diagnostics: diagnostics,
+                scopes: scopes,
+                codeActions: codeActions
+            });
         }
         return codeActions;
     }
@@ -1179,6 +1180,25 @@ export class Program {
         this.plugins.emit('afterProgramTranspile', this, entries);
     }
 
+    /**
+     * Find a list of files in the program that have a function with the given name (case INsensitive)
+     */
+    public findFilesForFunction(functionName: string) {
+        const files = [] as BscFile[];
+        const lowerFunctionName = functionName.toLowerCase();
+        //find every file with this function defined
+        for (const file of Object.values(this.files)) {
+            if (isBrsFile(file)) {
+                //TODO handle namespace-relative function calls
+                //if the file has a function with this name
+                if (file.parser.references.functionStatementLookup.get(lowerFunctionName) !== undefined) {
+                    files.push(file);
+                }
+            }
+        }
+        return files;
+    }
+
     /**
      * Get a map of the manifest information
      */
diff --git a/src/Scope.ts b/src/Scope.ts
index 30f58e29b..c3a9b2787 100644
--- a/src/Scope.ts
+++ b/src/Scope.ts
@@ -1,4 +1,4 @@
-import type { CodeAction, CompletionItem, Position, Range } from 'vscode-languageserver';
+import type { CompletionItem, Position, Range } from 'vscode-languageserver';
 import * as path from 'path';
 import { CompletionItemKind, Location } from 'vscode-languageserver';
 import chalk from 'chalk';
@@ -244,11 +244,6 @@ export class Scope {
         this.diagnostics.push(...diagnostics);
     }
 
-    public getCodeActions(file: BscFile, range: Range, codeActions: CodeAction[]) {
-        const diagnostics = this.diagnostics.filter(x => x.range?.start.line === range.start.line);
-        this.program.plugins.emit('onScopeGetCodeActions', this, file, range, diagnostics, codeActions);
-    }
-
     /**
      * Get the list of callables available in this scope (either declared in this scope or in a parent scope)
      */
diff --git a/src/XmlScope.ts b/src/XmlScope.ts
index da26d43c2..ecad3d547 100644
--- a/src/XmlScope.ts
+++ b/src/XmlScope.ts
@@ -1,4 +1,4 @@
-import type { CodeAction, Location, Position, Range } from 'vscode-languageserver';
+import type { Location, Position } from 'vscode-languageserver';
 import { Scope } from './Scope';
 import { DiagnosticMessages } from './DiagnosticMessages';
 import type { XmlFile } from './files/XmlFile';
@@ -153,11 +153,6 @@ export class XmlScope extends Scope {
         });
     }
 
-    public getCodeActions(file: BscFile, range: Range, codeActions: CodeAction[]) {
-        const relevantDiagnostics = this.diagnostics.filter(x => x.range?.start.line === range.start.line);
-        this.program.plugins.emit('onScopeGetCodeActions', this, file, range, relevantDiagnostics, codeActions);
-    }
-
     /**
      * Get the definition (where was this thing first defined) of the symbol under the position
      */
diff --git a/src/bscPlugin/BscPlugin.ts b/src/bscPlugin/BscPlugin.ts
index 15d0d9d7d..a60c38197 100644
--- a/src/bscPlugin/BscPlugin.ts
+++ b/src/bscPlugin/BscPlugin.ts
@@ -1,14 +1,10 @@
-import type { CodeAction, Range } from 'vscode-languageserver';
-import { isXmlFile } from '../astUtils/reflection';
-import type { BscFile, BsDiagnostic, CompilerPlugin } from '../interfaces';
-import { XmlFileCodeActionsProcessor } from './codeActions/XmlFileCodeActionsProcessor';
+import type { OnGetCodeActionsEvent, CompilerPlugin } from '../interfaces';
+import { CodeActionsProcessor } from './codeActions/CodeActionsProcessor';
 
 export class BscPlugin implements CompilerPlugin {
     public name = 'BscPlugin';
 
-    public onFileGetCodeActions(file: BscFile, range: Range, diagnostics: BsDiagnostic[], codeActions: CodeAction[]) {
-        if (isXmlFile(file)) {
-            new XmlFileCodeActionsProcessor(file, range, diagnostics, codeActions).process();
-        }
+    public onGetCodeActions(event: OnGetCodeActionsEvent) {
+        new CodeActionsProcessor(event).process();
     }
 }
diff --git a/src/bscPlugin/codeActions/CodeActionsProcessor.spec.ts b/src/bscPlugin/codeActions/CodeActionsProcessor.spec.ts
new file mode 100644
index 000000000..20c82dddc
--- /dev/null
+++ b/src/bscPlugin/codeActions/CodeActionsProcessor.spec.ts
@@ -0,0 +1,131 @@
+import { expect } from 'chai';
+import { URI } from 'vscode-uri';
+import { Program } from '../../Program';
+import { expectCodeActions, trim } from '../../testHelpers.spec';
+import { standardizePath as s, util } from '../../util';
+
+const rootDir = s`${process.cwd()}/.tmp/rootDir`;
+describe('CodeActionsProcessor', () => {
+    let program: Program;
+    beforeEach(() => {
+        program = new Program({
+            rootDir: rootDir
+        });
+    });
+    afterEach(() => {
+        program.dispose();
+    });
+
+    describe('getCodeActions', () => {
+        it('suggests `extends=Group`', () => {
+            const file = program.addOrReplaceFile('components/comp1.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="comp1">
+                </component>
+            `);
+            expectCodeActions(() => {
+                program.getCodeActions(
+                    file.pathAbsolute,
+                    //<comp|onent name="comp1">
+                    util.createRange(1, 5, 1, 5)
+                );
+            }, [{
+                title: `Extend "Group"`,
+                isPreferred: true,
+                kind: 'quickfix',
+                changes: [{
+                    filePath: s`${rootDir}/components/comp1.xml`,
+                    newText: ' extends="Group"',
+                    type: 'insert',
+                    //<component name="comp1"|>
+                    position: util.createPosition(1, 23)
+                }]
+            }, {
+                title: `Extend "Task"`,
+                kind: 'quickfix',
+                changes: [{
+                    filePath: s`${rootDir}/components/comp1.xml`,
+                    newText: ' extends="Task"',
+                    type: 'insert',
+                    //<component name="comp1"|>
+                    position: util.createPosition(1, 23)
+                }]
+            }, {
+                title: `Extend "ContentNode"`,
+                kind: 'quickfix',
+                changes: [{
+                    filePath: s`${rootDir}/components/comp1.xml`,
+                    newText: ' extends="ContentNode"',
+                    type: 'insert',
+                    //<component name="comp1"|>
+                    position: util.createPosition(1, 23)
+                }]
+            }]);
+        });
+
+        it('adds attribute at end of component with multiple attributes`', () => {
+            const file = program.addOrReplaceFile('components/comp1.xml', trim`
+                <?xml version="1.0" encoding="utf-8" ?>
+                <component name="comp1" attr2="attr3" attr3="attr3">
+                </component>
+            `);
+            const codeActions = program.getCodeActions(
+                file.pathAbsolute,
+                //<comp|onent name="comp1">
+                util.createRange(1, 5, 1, 5)
+            );
+
+            expect(
+                codeActions[0].edit.changes[URI.file(s`${rootDir}/components/comp1.xml`).toString()][0].range
+            ).to.eql(
+                util.createRange(1, 51, 1, 51)
+            );
+        });
+    });
+
+    it('does not produce duplicate code actions for bs imports', () => {
+        //define the function in two files
+        program.addOrReplaceFile('components/lib1.brs', `
+            sub doSomething()
+            end sub
+        `);
+        program.addOrReplaceFile('components/lib2.brs', `
+            sub doSomething()
+            end sub
+        `);
+
+        //use the function in this file
+        const componentCommonFile = program.addOrReplaceFile('components/ComponentCommon.bs', `
+            sub init()
+                doSomething()
+            end sub
+        `);
+
+        //import the file in two scopes
+        program.addOrReplaceFile('components/comp1.xml', trim`
+            <?xml version="1.0" encoding="utf-8" ?>
+            <component name="ChildScene">
+                <script uri="ComponentCommon.bs" />
+            </component>
+        `);
+        program.addOrReplaceFile('components/comp2.xml', trim`
+            <?xml version="1.0" encoding="utf-8" ?>
+            <component name="ChildScene">
+                <script uri="ComponentCommon.bs" />
+            </component>
+        `);
+
+        program.validate();
+
+        //we should only get each file import suggestion exactly once
+        const codeActions = program.getCodeActions(
+            componentCommonFile.pathAbsolute,
+            // doSome|thing()
+            util.createRange(2, 22, 2, 22)
+        );
+        expect(codeActions.map(x => x.title).sort()).to.eql([
+            `import "pkg:/components/lib1.brs"`,
+            `import "pkg:/components/lib2.brs"`
+        ]);
+    });
+});
diff --git a/src/bscPlugin/codeActions/CodeActionsProcessor.ts b/src/bscPlugin/codeActions/CodeActionsProcessor.ts
new file mode 100644
index 000000000..ded71f84c
--- /dev/null
+++ b/src/bscPlugin/codeActions/CodeActionsProcessor.ts
@@ -0,0 +1,108 @@
+import { CodeActionKind } from 'vscode-languageserver';
+import { codeActionUtil } from '../../CodeActionUtil';
+import type { DiagnosticMessageType } from '../../DiagnosticMessages';
+import { DiagnosticCodeMap } from '../../DiagnosticMessages';
+import type { BrsFile } from '../../files/BrsFile';
+import type { XmlFile } from '../../files/XmlFile';
+import type { OnGetCodeActionsEvent } from '../../interfaces';
+import { util } from '../../util';
+
+export class CodeActionsProcessor {
+    public constructor(
+        public event: OnGetCodeActionsEvent
+    ) {
+
+    }
+
+    public process() {
+        for (const diagnostic of this.event.diagnostics) {
+            if (diagnostic.code === DiagnosticCodeMap.callToUnknownFunction) {
+                this.suggestImports(diagnostic as any);
+            } else if (diagnostic.code === DiagnosticCodeMap.xmlComponentMissingExtendsAttribute) {
+                this.addMissingExtends(diagnostic as any);
+            }
+        }
+    }
+
+    private suggestedImports = new Set<string>();
+
+    private suggestImports(diagnostic: DiagnosticMessageType<'callToUnknownFunction'>) {
+        const lowerFunctionName = diagnostic.data.functionName.toLowerCase();
+
+        //skip generating duplicate suggestions if we've already done this one
+        if (this.suggestedImports.has(lowerFunctionName)) {
+            return;
+        }
+
+        this.suggestedImports.add(lowerFunctionName);
+        const importStatements = (this.event.file as BrsFile).parser.references.importStatements;
+        //find the position of the first import statement, or the top of the file if there is none
+        const insertPosition = importStatements[importStatements.length - 1]?.importToken.range?.start ?? util.createPosition(0, 0);
+
+        //find all files that reference this function
+        for (const file of this.event.file.program.findFilesForFunction(lowerFunctionName)) {
+            const pkgPath = util.getRokuPkgPath(file.pkgPath);
+            this.event.codeActions.push(
+                codeActionUtil.createCodeAction({
+                    title: `import "${pkgPath}"`,
+                    diagnostics: [diagnostic],
+                    isPreferred: false,
+                    kind: CodeActionKind.QuickFix,
+                    changes: [{
+                        type: 'insert',
+                        filePath: this.event.file.pathAbsolute,
+                        position: insertPosition,
+                        newText: `import "${pkgPath}"\n`
+                    }]
+                })
+            );
+        }
+    }
+
+    private addMissingExtends(diagnostic: DiagnosticMessageType<'xmlComponentMissingExtendsAttribute'>) {
+        const srcPath = this.event.file.pathAbsolute;
+        const { component } = (this.event.file as XmlFile).parser.ast;
+        //inject new attribute after the final attribute, or after the `<component` if there are no attributes
+        const pos = (component.attributes[component.attributes.length - 1] ?? component.tag).range.end;
+        this.event.codeActions.push(
+            codeActionUtil.createCodeAction({
+                title: `Extend "Group"`,
+                diagnostics: [diagnostic],
+                isPreferred: true,
+                kind: CodeActionKind.QuickFix,
+                changes: [{
+                    type: 'insert',
+                    filePath: srcPath,
+                    position: pos,
+                    newText: ' extends="Group"'
+                }]
+            })
+        );
+        this.event.codeActions.push(
+            codeActionUtil.createCodeAction({
+                title: `Extend "Task"`,
+                diagnostics: [diagnostic],
+                kind: CodeActionKind.QuickFix,
+                changes: [{
+                    type: 'insert',
+                    filePath: srcPath,
+                    position: pos,
+                    newText: ' extends="Task"'
+                }]
+            })
+        );
+        this.event.codeActions.push(
+            codeActionUtil.createCodeAction({
+                title: `Extend "ContentNode"`,
+                diagnostics: [diagnostic],
+                kind: CodeActionKind.QuickFix,
+                changes: [{
+                    type: 'insert',
+                    filePath: srcPath,
+                    position: pos,
+                    newText: ' extends="ContentNode"'
+                }]
+            })
+        );
+    }
+}
diff --git a/src/bscPlugin/codeActions/XmlFileCodeActionsProcessor.ts b/src/bscPlugin/codeActions/XmlFileCodeActionsProcessor.ts
deleted file mode 100644
index a1962a2aa..000000000
--- a/src/bscPlugin/codeActions/XmlFileCodeActionsProcessor.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import type { CodeAction, Range } from 'vscode-languageserver';
-import { CodeActionKind } from 'vscode-languageserver';
-import { codeActionUtil } from '../../CodeActionUtil';
-import { DiagnosticCodeMap } from '../../DiagnosticMessages';
-import type { XmlFile } from '../../files/XmlFile';
-import type { BsDiagnostic } from '../../interfaces';
-
-export class XmlFileCodeActionsProcessor {
-    public constructor(
-        public file: XmlFile,
-        public range: Range,
-        public diagnostics: BsDiagnostic[],
-        public codeActions: CodeAction[]
-    ) {
-
-    }
-
-    public process() {
-        for (const diagnostic of this.diagnostics) {
-            if (diagnostic.code === DiagnosticCodeMap.xmlComponentMissingExtendsAttribute) {
-                this.addMissingExtends();
-            }
-        }
-    }
-
-    private addMissingExtends() {
-        const { component } = this.file.parser.ast;
-        //inject new attribute after the final attribute, or after the `<component` if there are no attributes
-        const pos = (component.attributes[component.attributes.length - 1] ?? component.tag).range.end;
-        this.codeActions.push(
-            codeActionUtil.createCodeAction({
-                title: `Extend "Group"`,
-                // diagnostics: [diagnostic],
-                isPreferred: true,
-                kind: CodeActionKind.QuickFix,
-                changes: [{
-                    type: 'insert',
-                    filePath: this.file.pathAbsolute,
-                    position: pos,
-                    newText: ' extends="Group"'
-                }]
-            })
-        );
-        this.codeActions.push(
-            codeActionUtil.createCodeAction({
-                title: `Extend "Task"`,
-                // diagnostics: [diagnostic],
-                kind: CodeActionKind.QuickFix,
-                changes: [{
-                    type: 'insert',
-                    filePath: this.file.pathAbsolute,
-                    position: pos,
-                    newText: ' extends="Task"'
-                }]
-            })
-        );
-        this.codeActions.push(
-            codeActionUtil.createCodeAction({
-                title: `Extend "ContentNode"`,
-                // diagnostics: [diagnostic],
-                kind: CodeActionKind.QuickFix,
-                changes: [{
-                    type: 'insert',
-                    filePath: this.file.pathAbsolute,
-                    position: pos,
-                    newText: ' extends="ContentNode"'
-                }]
-            })
-        );
-    }
-}
diff --git a/src/files/BrsFile.ts b/src/files/BrsFile.ts
index 73fa9105c..fb9f2e245 100644
--- a/src/files/BrsFile.ts
+++ b/src/files/BrsFile.ts
@@ -1,6 +1,6 @@
 import type { CodeWithSourceMap } from 'source-map';
 import { SourceNode } from 'source-map';
-import type { CompletionItem, Hover, Range, Position, CodeAction } from 'vscode-languageserver';
+import type { CompletionItem, Hover, Range, Position } from 'vscode-languageserver';
 import { CompletionItemKind, SymbolKind, Location, SignatureInformation, ParameterInformation, DocumentSymbol, SymbolInformation, TextEdit } from 'vscode-languageserver';
 import chalk from 'chalk';
 import * as path from 'path';
@@ -1535,11 +1535,6 @@ export class BrsFile {
         }
     }
 
-    public getCodeActions(range: Range, codeActions: CodeAction[]) {
-        const relevantDiagnostics = this.diagnostics.filter(x => x.range?.start.line === range.start.line);
-        this.program.plugins.emit('onFileGetCodeActions', this, range, relevantDiagnostics, codeActions);
-    }
-
     public getSignatureHelpForNamespaceMethods(callableName: string, dottedGetText: string, scope: Scope): { key: string; signature: SignatureInformation }[] {
         if (!dottedGetText) {
             return [];
diff --git a/src/files/XmlFile.spec.ts b/src/files/XmlFile.spec.ts
index 2c4c2a4c1..9bbac5b44 100644
--- a/src/files/XmlFile.spec.ts
+++ b/src/files/XmlFile.spec.ts
@@ -1,7 +1,7 @@
 import { assert, expect } from 'chai';
 import * as path from 'path';
 import * as sinonImport from 'sinon';
-import type { CodeAction, CompletionItem } from 'vscode-languageserver';
+import type { CompletionItem } from 'vscode-languageserver';
 import { CompletionItemKind, Position, Range, DiagnosticSeverity } from 'vscode-languageserver';
 import * as fsExtra from 'fs-extra';
 import { DiagnosticMessages } from '../DiagnosticMessages';
@@ -9,10 +9,9 @@ import type { BsDiagnostic, FileReference } from '../interfaces';
 import { Program } from '../Program';
 import { BrsFile } from './BrsFile';
 import { XmlFile } from './XmlFile';
-import util, { standardizePath as s } from '../util';
+import { standardizePath as s } from '../util';
 import { getTestTranspile } from './BrsFile.spec';
-import { expectCodeActions, expectZeroDiagnostics, trim, trimMap } from '../testHelpers.spec';
-import { URI } from 'vscode-uri';
+import { expectZeroDiagnostics, trim, trimMap } from '../testHelpers.spec';
 
 describe('XmlFile', () => {
     const tempDir = s`${process.cwd()}/.tmp`;
@@ -1094,69 +1093,4 @@ describe('XmlFile', () => {
         `);
         expect(file.scriptTagImports[0]?.text).to.eql('SingleQuotedFile.brs');
     });
-
-    describe('getCodeActions', () => {
-        it('suggests `extends=Group`', () => {
-            const file = program.addOrReplaceFile('components/comp1.xml', trim`
-                <?xml version="1.0" encoding="utf-8" ?>
-                <component name="comp1">
-                </component>
-            `);
-            expectCodeActions(() => {
-                file.getCodeActions(
-                    //<comp|onent name="comp1">
-                    util.createRange(1, 5, 1, 5), []
-                );
-            }, [{
-                title: `Extend "Group"`,
-                isPreferred: true,
-                kind: 'quickfix',
-                changes: [{
-                    filePath: s`${rootDir}/components/comp1.xml`,
-                    newText: ' extends="Group"',
-                    type: 'insert',
-                    //<component name="comp1"|>
-                    position: util.createPosition(1, 23)
-                }]
-            }, {
-                title: `Extend "Task"`,
-                kind: 'quickfix',
-                changes: [{
-                    filePath: s`${rootDir}/components/comp1.xml`,
-                    newText: ' extends="Task"',
-                    type: 'insert',
-                    //<component name="comp1"|>
-                    position: util.createPosition(1, 23)
-                }]
-            }, {
-                title: `Extend "ContentNode"`,
-                kind: 'quickfix',
-                changes: [{
-                    filePath: s`${rootDir}/components/comp1.xml`,
-                    newText: ' extends="ContentNode"',
-                    type: 'insert',
-                    //<component name="comp1"|>
-                    position: util.createPosition(1, 23)
-                }]
-            }]);
-        });
-
-        it('adds attribute at end of component with multiple attributes`', () => {
-            const file = program.addOrReplaceFile('components/comp1.xml', trim`
-                <?xml version="1.0" encoding="utf-8" ?>
-                <component name="comp1" attr2="attr3" attr3="attr3">
-                </component>
-            `);
-            const codeActions = [] as CodeAction[];
-            file.getCodeActions(
-                //<comp|onent name="comp1">
-                util.createRange(1, 5, 1, 5), codeActions
-            );
-            expect(
-                codeActions[0].edit.changes[URI.file(s`${rootDir}/components/comp1.xml`).toString()][0].range
-            ).to.eql(
-                util.createRange(1, 51, 1, 51)
-            );
-        });
-    });
 });
diff --git a/src/files/XmlFile.ts b/src/files/XmlFile.ts
index 0735e5147..ee927ea9f 100644
--- a/src/files/XmlFile.ts
+++ b/src/files/XmlFile.ts
@@ -1,7 +1,7 @@
 import * as path from 'path';
 import type { CodeWithSourceMap } from 'source-map';
 import { SourceNode } from 'source-map';
-import type { CodeAction, CompletionItem, Hover, Location, Position, Range } from 'vscode-languageserver';
+import type { CompletionItem, Hover, Location, Position, Range } from 'vscode-languageserver';
 import { DiagnosticMessages } from '../DiagnosticMessages';
 import type { FunctionScope } from '../FunctionScope';
 import type { Callable, BsDiagnostic, File, FileReference, FunctionCall } from '../interfaces';
@@ -369,11 +369,6 @@ export class XmlFile {
         return null;
     }
 
-    public getCodeActions(range: Range, codeActions: CodeAction[]) {
-        const relevantDiagnostics = this.diagnostics.filter(x => x.range?.start.line === range.start.line);
-        this.program.plugins.emit('onFileGetCodeActions', this, range, relevantDiagnostics, codeActions);
-    }
-
     public getReferences(position: Position): Promise<Location[]> { //eslint-disable-line
         //TODO implement
         return null;
diff --git a/src/interfaces.ts b/src/interfaces.ts
index 5083f4c34..7eb66f079 100644
--- a/src/interfaces.ts
+++ b/src/interfaces.ts
@@ -192,15 +192,13 @@ export interface CompilerPlugin {
     afterProgramValidate?: (program: Program) => void;
     beforeProgramTranspile?: (program: Program, entries: TranspileObj[]) => void;
     afterProgramTranspile?: (program: Program, entries: TranspileObj[]) => void;
-    beforeProgramGetCodeActions?: (program: Program, file: BscFile, range: Range, codeActions: CodeAction[]) => void;
-    afterProgramGetCodeActions?: (program: Program, file: BscFile, range: Range, codeActions: CodeAction[]) => void;
+    onGetCodeActions?: PluginHandler<OnGetCodeActionsEvent>;
     //scope events
     afterScopeCreate?: (scope: Scope) => void;
     beforeScopeDispose?: (scope: Scope) => void;
     afterScopeDispose?: (scope: Scope) => void;
     beforeScopeValidate?: ValidateHandler;
     afterScopeValidate?: ValidateHandler;
-    onScopeGetCodeActions?: (scope: Scope, file: BscFile, range: Range, diagnostics: BsDiagnostic[], codeActions: CodeAction[]) => void;
     //file events
     beforeFileParse?: (source: SourceObj) => void;
     afterFileParse?: (file: BscFile) => void;
@@ -209,7 +207,16 @@ export interface CompilerPlugin {
     afterFileTranspile?: (entry: TranspileObj) => void;
     beforeFileDispose?: (file: BscFile) => void;
     afterFileDispose?: (file: BscFile) => void;
-    onFileGetCodeActions?: (file: BscFile, range: Range, diagnostics: BsDiagnostic[], codeActions: CodeAction[]) => void;
+}
+export type PluginHandler<T> = (event: T) => void;
+
+export interface OnGetCodeActionsEvent {
+    program: Program;
+    file: BscFile;
+    range: Range;
+    scopes: Scope[];
+    diagnostics: BsDiagnostic[];
+    codeActions: CodeAction[];
 }
 
 export interface TypedefProvider {
diff --git a/src/parser/Parser.ts b/src/parser/Parser.ts
index 2fa759131..6b141b012 100644
--- a/src/parser/Parser.ts
+++ b/src/parser/Parser.ts
@@ -124,7 +124,7 @@ export class Parser {
         return this._references;
     }
 
-    private _references: References = createReferences();
+    private _references = new References();
 
     /**
      * Invalidates (clears) the references collection. This should be called anytime the AST has been manipulated.
@@ -2571,7 +2571,7 @@ export class Parser {
      * This does that walk.
      */
     private findReferences() {
-        this._references = createReferences();
+        this._references = new References();
 
         this.ast.walk(createVisitor({
             AssignmentStatement: s => {
@@ -2634,30 +2634,29 @@ export interface ParseOptions {
     logger?: Logger;
 }
 
-function createReferences(): References {
-    return {
-        assignmentStatements: [],
-        classStatements: [],
-        functionExpressions: [],
-        functionStatements: [],
-        importStatements: [],
-        libraryStatements: [],
-        namespaceStatements: [],
-        newExpressions: [],
-        propertyHints: {}
-    };
-}
-
-export interface References {
-    assignmentStatements: AssignmentStatement[];
-    classStatements: ClassStatement[];
-    functionExpressions: FunctionExpression[];
-    functionStatements: FunctionStatement[];
-    importStatements: ImportStatement[];
-    libraryStatements: LibraryStatement[];
-    namespaceStatements: NamespaceStatement[];
-    newExpressions: NewExpression[];
-    propertyHints: Record<string, string>;
+export class References {
+    public assignmentStatements = [] as AssignmentStatement[];
+    public classStatements = [] as ClassStatement[];
+    public functionExpressions = [] as FunctionExpression[];
+    public functionStatements = [] as FunctionStatement[];
+    /**
+     * A map of function statements, indexed by fully-namespaced lower function name.
+     */
+    public get functionStatementLookup() {
+        if (!this._functionStatementLookup) {
+            this._functionStatementLookup = new Map();
+            for (const stmt of this.functionStatements) {
+                this._functionStatementLookup.set(stmt.getName(ParseMode.BrighterScript).toLowerCase(), stmt);
+            }
+        }
+        return this._functionStatementLookup;
+    }
+    private _functionStatementLookup: Map<string, FunctionStatement>;
+    public importStatements = [] as ImportStatement[];
+    public libraryStatements = [] as LibraryStatement[];
+    public namespaceStatements = [] as NamespaceStatement[];
+    public newExpressions = [] as NewExpression[];
+    public propertyHints = {} as Record<string, string>;
 }
 
 class CancelStatementError extends Error {
diff --git a/src/testHelpers.spec.ts b/src/testHelpers.spec.ts
index ff7a94ca4..875101908 100644
--- a/src/testHelpers.spec.ts
+++ b/src/testHelpers.spec.ts
@@ -95,6 +95,9 @@ export function expectCodeActions(test: () => any, expected: CodeActionShorthand
     }
 
     const args = stub.getCalls().map(x => x.args[0]);
-
+    //delete any `diagnostics` arrays to help with testing performance (since it's circular...causes all sorts of issues)
+    for (let arg of args) {
+        delete arg.diagnostics;
+    }
     expect(args).to.eql(expected);
 }
diff --git a/src/util.spec.ts b/src/util.spec.ts
index 07cb26e1b..6563c46ea 100644
--- a/src/util.spec.ts
+++ b/src/util.spec.ts
@@ -642,4 +642,78 @@ describe('util', () => {
             ).not.to.be.null;
         });
     });
+
+    describe('rangesIntersect', () => {
+        it('does not match when ranges touch at right edge', () => {
+            // AABB
+            expect(util.rangesIntersect(
+                util.createRange(0, 0, 0, 1),
+                util.createRange(0, 1, 0, 2)
+            )).to.be.false;
+        });
+
+        it('does not match when ranges touch at left edge', () => {
+            // BBAA
+            expect(util.rangesIntersect(
+                util.createRange(0, 1, 0, 2),
+                util.createRange(0, 0, 0, 1)
+            )).to.be.false;
+        });
+
+        it('matches when range overlaps by single character on the right', () => {
+            // A BA B
+            expect(util.rangesIntersect(
+                util.createRange(0, 1, 0, 3),
+                util.createRange(0, 2, 0, 4)
+            )).to.be.true;
+        });
+
+        it('matches when range overlaps by single character on the left', () => {
+            // B AB A
+            expect(util.rangesIntersect(
+                util.createRange(0, 2, 0, 4),
+                util.createRange(0, 1, 0, 3)
+            )).to.be.true;
+        });
+
+        it('matches when A is contained by B at the edges', () => {
+            // B AA B
+            expect(util.rangesIntersect(
+                util.createRange(0, 2, 0, 3),
+                util.createRange(0, 1, 0, 4)
+            )).to.be.true;
+        });
+
+        it('matches when B is contained by A at the edges', () => {
+            // A BB A
+            expect(util.rangesIntersect(
+                util.createRange(0, 1, 0, 4),
+                util.createRange(0, 2, 0, 3)
+            )).to.be.true;
+        });
+
+        it('matches when A and B are identical', () => {
+            // ABBA
+            expect(util.rangesIntersect(
+                util.createRange(0, 1, 0, 2),
+                util.createRange(0, 1, 0, 2)
+            )).to.be.true;
+        });
+
+        it('matches when A spans multiple lines', () => {
+            // ABBA
+            expect(util.rangesIntersect(
+                util.createRange(0, 1, 2, 0),
+                util.createRange(0, 1, 0, 3)
+            )).to.be.true;
+        });
+
+        it('matches when B spans multiple lines', () => {
+            // ABBA
+            expect(util.rangesIntersect(
+                util.createRange(0, 1, 0, 3),
+                util.createRange(0, 1, 2, 0)
+            )).to.be.true;
+        });
+    });
 });
diff --git a/src/util.ts b/src/util.ts
index d1dcb3a0f..05d605c4f 100644
--- a/src/util.ts
+++ b/src/util.ts
@@ -4,7 +4,7 @@ import type { ParseError } from 'jsonc-parser';
 import { parse as parseJsonc, printParseErrorCode } from 'jsonc-parser';
 import * as path from 'path';
 import * as rokuDeploy from 'roku-deploy';
-import type { Position, Range } from 'vscode-languageserver';
+import type { Diagnostic, Position, Range } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
 import * as xml2js from 'xml2js';
 import type { BsConfig } from './BsConfig';
@@ -466,6 +466,24 @@ export class Util {
         }
     }
 
+    /**
+     * Does a touch b in any way?
+     */
+    public rangesIntersect(a: Range, b: Range) {
+        // Check if `a` is before `b`
+        if (a.end.line < b.start.line || (a.end.line === b.start.line && a.end.character <= b.start.character)) {
+            return false;
+        }
+
+        // Check if `b` is before `a`
+        if (b.end.line < a.start.line || (b.end.line === a.start.line && b.end.character <= a.start.character)) {
+            return false;
+        }
+
+        // These ranges must intersect
+        return true;
+    }
+
     /**
      * Test if `position` is in `range`. If the position is at the edges, will return true.
      * Adapted from core vscode
@@ -1201,6 +1219,23 @@ export class Util {
         }
         await fsExtra.writeFile(`${stagingDir}/source/bslib.brs`, source);
     }
+
+    /**
+     * Given a Diagnostic or BsDiagnostic, return a copy of the diagnostic
+     */
+    public toDiagnostic(diagnostic: Diagnostic | BsDiagnostic) {
+        return {
+            severity: diagnostic.severity,
+            range: diagnostic.range,
+            message: diagnostic.message,
+            relatedInformation: diagnostic.relatedInformation?.map(x => {
+                //clone related information just in case a plugin added circular ref info here
+                return { ...x };
+            }),
+            code: diagnostic.code,
+            source: 'brs'
+        };
+    }
 }
 
 /**