Introduce code analysis limit

Author: dklilley

matlab/+matlabls/+handlers/IndexingHandler.m

@@ -25,8 +25,9 @@ function handleDocumentIndexRequest (this, msg)
 
             code = msg.code;
             filePath = msg.filePath;
+            analysisLimit = msg.analysisLimit;
 
-            codeData = matlabls.internal.computeCodeData(code, filePath);
+            codeData = matlabls.internal.computeCodeData(code, filePath, analysisLimit);
 
             responseChannel = strcat(this.DocumentIndexingResponseChannel, '/', msg.channelId);
             matlabls.internal.CommunicationManager.publish(responseChannel, codeData)
@@ -36,9 +37,10 @@ function handleFolderIndexRequest (this, msg)
             % Indexes M-files the provided folders
 
             folders = msg.folders;
+            analysisLimit = msg.analysisLimit;
 
             files = this.getAllMFilesToIndex(folders);
-            this.parseFiles(msg.channelId, files)
+            this.parseFiles(msg.channelId, files, analysisLimit)
         end
 
         function filesToIndex = getAllMFilesToIndex (~, folders)
@@ -56,30 +58,30 @@ function handleFolderIndexRequest (this, msg)
             end
         end
 
-        function parseFiles (this, requestId, files)
+        function parseFiles (this, requestId, files, analysisLimit)
             % Processes the given list of files and sends the data back to the language server.
 
             if isMATLABReleaseOlderThan('R2021b')
                 % If backgroundPool doesn't exist, leverage a timer to avoid blocking thread
-                this.doParseFilesWithTimer(this, requestId, files);
+                this.doParseFilesWithTimer(this, requestId, files, analysisLimit);
             else
-                parfeval(backgroundPool, @this.doParseFiles, 0, requestId, files);
+                parfeval(backgroundPool, @this.doParseFiles, 0, requestId, files, analysisLimit);
             end
         end
 
-        function doParseFilesWithTimer (this, requestId, files, index)
+        function doParseFilesWithTimer (this, requestId, files, analysisLimit, index)
             % This leverages a timer to achieve an "asynchronous" looping effect, allowing
             % other operations to take place between parsing each file. This prevents the MATLAB®
             % thread from becomming blocked for an extended period of time.
 
-            if nargin == 3
+            if nargin == 4
                 index = 1;
             end
 
             filePath = files(index);
             isLastFile = index == numel(files);
 
-            this.parseFile(requestId, filePath, isLastFile);
+            this.parseFile(requestId, filePath, isLastFile, analysisLimit);
 
             if ~isLastFile
                 % More files - queue next file to parse
@@ -93,26 +95,26 @@ function timerCallback (t, ~)
                 t.delete();
 
                 % Parse next file
-                this.parseFiles(requestId, files, index + 1);
+                this.doParseFilesWithTimer(requestId, files, analysisLimit, index + 1);
             end
         end
 
-        function doParseFiles (this, requestId, files)
+        function doParseFiles (this, requestId, files, analysisLimit)
             % This can be executed in a separate thread (e.g. parfeval) to avoid blocking the
             % MATLAB thread.
 
             for n = 1:numel(files)
                 filePath = files{n};
                 isLastFile = n == numel(files);
-                this.parseFile(requestId, filePath, isLastFile);
+                this.parseFile(requestId, filePath, isLastFile, analysisLimit);
             end
         end
 
-        function parseFile (this, requestId, filePath, isLastFile)
+        function parseFile (this, requestId, filePath, isLastFile, analysisLimit)
             % Parses the given file and sends its data back to the language server
 
             code = fileread(filePath);
-            codeData = matlabls.internal.computeCodeData(code, filePath);
+            codeData = matlabls.internal.computeCodeData(code, filePath, analysisLimit);
 
             % Send data for this file
             msg.filePath = filePath;

matlab/+matlabls/+internal/computeCodeData.m

@@ -1,4 +1,4 @@
-function codeInfo = computeCodeData (code, filePath)
+function codeInfo = computeCodeData (code, filePath, analysisLimit)
     %COMPUTECODEDATA Compute sub-function location information for the
     % MATLAB® code file specified by fullpath. The data is a struct:
     %
@@ -42,8 +42,7 @@
     functionReferences = {};
 
     %% Handle very large input
-    MAXCODE = 500000;
-    if strlength(code) > MAXCODE
+    if analysisLimit > 0 && strlength(code) > analysisLimit
         % File too large - do not try to index
         code = '';
     end

src/indexing/Indexer.ts

@@ -7,6 +7,7 @@ import MatlabLifecycleManager from '../lifecycle/MatlabLifecycleManager'
 import FileInfoIndex, { MatlabCodeData, RawCodeData } from './FileInfoIndex'
 import * as fs from 'fs/promises'
 import PathResolver from '../providers/navigation/PathResolver'
+import ConfigurationManager from '../lifecycle/ConfigurationManager'
 
 interface WorkspaceFileIndexedResponse {
     isDone: boolean
@@ -69,9 +70,12 @@ export default class Indexer {
             FileInfoIndex.parseAndStoreCodeData(fileUri, fileResults.codeData)
         })
 
+        const analysisLimit = (await ConfigurationManager.getConfiguration()).codeAnalysisCharacterLimit
+
         matlabConnection.publish(this.INDEX_FOLDERS_REQUEST_CHANNEL, {
             folders,
-            channelId
+            channelId,
+            analysisLimit
         })
     }
 
@@ -106,7 +110,7 @@ export default class Indexer {
     private async getCodeData (code: string, uri: string, matlabConnection: MatlabConnection): Promise<RawCodeData> {
         const filePath = URI.parse(uri).fsPath
 
-        return await new Promise(resolve => {
+        return await new Promise(async resolve => {
             const channelId = matlabConnection.getChannelId()
             const channel = `${this.INDEX_DOCUMENT_RESPONSE_CHANNEL}/${channelId}`
             const responseSub = matlabConnection.subscribe(channel, message => {
@@ -115,10 +119,13 @@ export default class Indexer {
                 resolve(message as RawCodeData)
             })
 
+            const analysisLimit = (await ConfigurationManager.getConfiguration()).codeAnalysisCharacterLimit
+
             matlabConnection.publish(this.INDEX_DOCUMENT_REQUEST_CHANNEL, {
                 code,
                 filePath,
-                channelId
+                channelId,
+                analysisLimit
             })
         })
     }

src/lifecycle/ConfigurationManager.ts

@@ -33,15 +33,17 @@ interface Settings {
     matlabConnectionTiming: ConnectionTiming
     indexWorkspace: boolean
     telemetry: boolean
+    codeAnalysisCharacterLimit: number
 }
 
-type SettingName = 'installPath' | 'matlabConnectionTiming' | 'indexWorkspace' | 'telemetry'
+type SettingName = 'installPath' | 'matlabConnectionTiming' | 'indexWorkspace' | 'telemetry' | 'codeAnalysisCharacterLimit'
 
 const SETTING_NAMES: SettingName[] = [
     'installPath',
     'matlabConnectionTiming',
     'indexWorkspace',
-    'telemetry'
+    'telemetry',
+    'codeAnalysisCharacterLimit'
 ]
 
 class ConfigurationManager {
@@ -63,14 +65,16 @@ class ConfigurationManager {
             installPath: '',
             matlabConnectionTiming: ConnectionTiming.OnStart,
             indexWorkspace: false,
-            telemetry: true
+            telemetry: true,
+            codeAnalysisCharacterLimit: 0
         }
 
         this.globalSettings = {
             installPath: cliArgs[Argument.MatlabInstallationPath] ?? this.defaultConfiguration.installPath,
             matlabConnectionTiming: cliArgs[Argument.MatlabConnectionTiming] as ConnectionTiming ?? this.defaultConfiguration.matlabConnectionTiming,
             indexWorkspace: cliArgs[Argument.ShouldIndexWorkspace] ?? this.defaultConfiguration.indexWorkspace,
-            telemetry: this.defaultConfiguration.telemetry
+            telemetry: this.defaultConfiguration.telemetry,
+            codeAnalysisCharacterLimit: this.defaultConfiguration.codeAnalysisCharacterLimit
         }
 
         this.additionalArguments = {

src/providers/linting/LintingSupportProvider.ts

@@ -95,10 +95,16 @@ class LintingSupportProvider {
         const fileName = URI.parse(uri).fsPath
 
         let lintData: string[] = []
+        const code = textDocument.getText()
+        
+        const analysisLimit = (await ConfigurationManager.getConfiguration()).codeAnalysisCharacterLimit
+        if (analysisLimit > 0 && code.length > analysisLimit) {
+            this.clearDiagnosticsForDocument(textDocument) // Clear document to handle setting changing value
+            return
+        }
 
         if (isMatlabAvailable) {
             // Use MATLAB-based linting for better results and fixes
-            const code = textDocument.getText()
             lintData = await this.getLintResultsFromMatlab(code, fileName, matlabConnection)
         } else {
             // Try to use mlint executable for basic linting