fix: #165 disable completion in comments

Author: liuxy0551

src/languageFeatures.ts

@@ -5,6 +5,7 @@ import { WordPosition } from 'dt-sql-parser/dist/parser/common/textAndWord';
 import * as monaco from 'monaco-editor';
 
 import { BaseSQLWorker } from './baseSQLWorker';
+import { TokenClassConsts } from './common/constants';
 import { debounce } from './common/utils';
 import {
 	CancellationToken,
@@ -145,6 +146,25 @@ function toDiagnostics(_resource: Uri, diag: ParseError): editor.IMarkerData {
 	};
 }
 
+function isPositionInComment(model: editor.IReadOnlyModel, position: Position): boolean {
+	const textBeforePosition = model.getValueInRange(
+		new Range(1, 1, position.lineNumber, position.column)
+	);
+	// 在光标处追加哨兵字符，避免将刚结束的块注释误判为仍在注释中
+	const tokenizedLines = editor.tokenize(`${textBeforePosition}x`, model.getLanguageId());
+	const lineTokens = tokenizedLines[tokenizedLines.length - 1] || [];
+	const sentinelOffset = position.column - 1;
+
+	for (let index = lineTokens.length - 1; index >= 0; index--) {
+		const token = lineTokens[index];
+		if (token.offset <= sentinelOffset) {
+			return token.type.startsWith(TokenClassConsts.COMMENT);
+		}
+	}
+
+	return false;
+}
+
 export class CompletionAdapter<T extends BaseSQLWorker>
 	implements languages.CompletionItemProvider
 {
@@ -165,6 +185,10 @@ export class CompletionAdapter<T extends BaseSQLWorker>
 		context: languages.CompletionContext,
 		_token: CancellationToken
 	): Promise<languages.CompletionList> {
+		if (isPositionInComment(model, position)) {
+			return Promise.resolve({ suggestions: [] });
+		}
+
 		const resource = model.uri;
 		return this._worker(resource)
 			.then((worker) => {

src/languages/mysql/mysql.completion.test.ts

@@ -0,0 +1,146 @@
+import * as assert from 'assert';
+
+import { BaseSQLWorker } from '../../baseSQLWorker';
+import {
+	CancellationTokenSource,
+	editor,
+	languages,
+	Position
+} from '../../fillers/monaco-editor-core';
+import { CompletionAdapter, WorkerAccessor } from '../../languageFeatures';
+import { LanguageServiceDefaultsImpl, modeConfigurationDefault } from '../../monaco.contribution';
+import { language } from './mysql';
+
+const LANGUAGE_ID = 'mysql-completion-test';
+
+languages.register({ id: LANGUAGE_ID });
+languages.setMonarchTokensProvider(LANGUAGE_ID, language);
+
+interface CompletionResult {
+	suggestions: languages.CompletionItem[];
+	workerCallCount: number;
+}
+
+function getEndPosition(value: string): Position {
+	const lines = value.split('\n');
+	return new Position(lines.length, lines[lines.length - 1].length + 1);
+}
+
+async function provideCompletionItems(
+	value: string,
+	position: Position = getEndPosition(value)
+): Promise<CompletionResult> {
+	const model = editor.createModel(value, LANGUAGE_ID);
+	const cancellationTokenSource = new CancellationTokenSource();
+	let workerCallCount = 0;
+	const worker: WorkerAccessor<BaseSQLWorker> = async () => {
+		workerCallCount++;
+		return {
+			doCompletionWithEntities: async () => ({
+				suggestions: {
+					syntax: [],
+					keywords: ['SELECT']
+				},
+				allEntities: null,
+				context: null
+			})
+		} as unknown as BaseSQLWorker;
+	};
+	const defaults = new LanguageServiceDefaultsImpl(LANGUAGE_ID, modeConfigurationDefault);
+	const adapter = new CompletionAdapter(worker, defaults);
+
+	try {
+		const completionList = await adapter.provideCompletionItems(
+			model,
+			position,
+			{ triggerKind: languages.CompletionTriggerKind.Invoke },
+			cancellationTokenSource.token
+		);
+
+		return {
+			suggestions: completionList.suggestions,
+			workerCallCount
+		};
+	} finally {
+		cancellationTokenSource.dispose();
+		model.dispose();
+	}
+}
+
+test('does not provide completion items after a line comment marker', async () => {
+	const result = await provideCompletionItems('--');
+
+	assert.deepStrictEqual(result.suggestions, []);
+	assert.strictEqual(result.workerCallCount, 0);
+});
+
+test('does not provide completion items inside an inline line comment', async () => {
+	const result = await provideCompletionItems('SELECT 1 -- comment');
+
+	assert.deepStrictEqual(result.suggestions, []);
+	assert.strictEqual(result.workerCallCount, 0);
+});
+
+test('does not provide completion items inside a MySQL hash comment', async () => {
+	const result = await provideCompletionItems('# comment');
+
+	assert.deepStrictEqual(result.suggestions, []);
+	assert.strictEqual(result.workerCallCount, 0);
+});
+
+test('does not provide completion items inside a block comment', async () => {
+	const result = await provideCompletionItems('/* comment */', new Position(1, 4));
+
+	assert.deepStrictEqual(result.suggestions, []);
+	assert.strictEqual(result.workerCallCount, 0);
+});
+
+test('does not provide completion items inside a multiline block comment', async () => {
+	const result = await provideCompletionItems(
+		'SELECT /* comment\nstill comment */',
+		new Position(2, 6)
+	);
+
+	assert.deepStrictEqual(result.suggestions, []);
+	assert.strictEqual(result.workerCallCount, 0);
+});
+
+test('provides completion items after a closed block comment', async () => {
+	const result = await provideCompletionItems('SELECT /* comment */');
+
+	assert.deepStrictEqual(
+		result.suggestions.map((item) => item.label),
+		['SELECT']
+	);
+	assert.strictEqual(result.workerCallCount, 1);
+});
+
+test('does not treat comment markers inside strings as comments', async () => {
+	const result = await provideCompletionItems("SELECT '--'");
+
+	assert.deepStrictEqual(
+		result.suggestions.map((item) => item.label),
+		['SELECT']
+	);
+	assert.strictEqual(result.workerCallCount, 1);
+});
+
+test('does not treat a single minus sign as a comment', async () => {
+	const result = await provideCompletionItems('-');
+
+	assert.deepStrictEqual(
+		result.suggestions.map((item) => item.label),
+		['SELECT']
+	);
+	assert.strictEqual(result.workerCallCount, 1);
+});
+
+test('keeps the existing completion flow for regular SQL', async () => {
+	const result = await provideCompletionItems('SELECT ');
+
+	assert.deepStrictEqual(
+		result.suggestions.map((item) => item.label),
+		['SELECT']
+	);
+	assert.strictEqual(result.workerCallCount, 1);
+});

test/setup.js

@@ -29,6 +29,17 @@ define('vs/nls', [], {
 	}
 });
 
+define('dt-sql-parser', [], {
+	EntityContextType: {
+		TABLE: 'table',
+		TABLE_CREATE: 'tableCreate'
+	}
+});
+
+define('monaco-editor', ['vs/editor/editor.main'], function (api) {
+	return api.m || api;
+});
+
 define(['vs/editor/editor.main'], function (api) {
 	// Monaco Editor 0.54.0+ exports as api.m instead of api directly
 	const monaco = api.m || api;