Drop dedent-on-enter for "return" statements.

news/2 Fixes/6813.md

@@ -0,0 +1,2 @@
+Drop dedent-on-enter for "return" statements. It will be addressed in:
+ https://github.com/microsoft/vscode-python/issues/6564

src/client/common/utils/regexp.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+/* Generate a RegExp from a "verbose" pattern.
+ *
+ * All whitespace in the pattern is removed, including newlines. This
+ * allows the pattern to be much more readable by allowing it to span
+ * multiple lines and to separate tokens with insignificant whitespace.
+ * The functionality is similar to the VERBOSE ("x") flag in Python's
+ * regular expressions.
+ *
+ * Note that significant whitespace in the pattern must be explicitly
+ * indicated by "\s". Also, unlike with regular expression literals,
+ * backslashes must be escaped. Conversely, forward slashes do not
+ * need to be escaped.
+ */
+export function verboseRegExp(pattern: string): RegExp {
+ pattern = pattern.replace(/\s+?/g, '');
+ return RegExp(pattern);
+}

src/client/extension.ts

@@ -40,7 +40,7 @@ import { registerTypes as appRegisterTypes } from './application/serviceRegistry
 import { IApplicationDiagnostics } from './application/types';
 import { DebugService } from './common/application/debugService';
 import { IApplicationShell, ICommandManager, IWorkspaceService } from './common/application/types';
-import { Commands, isTestExecution, PYTHON, STANDARD_OUTPUT_CHANNEL } from './common/constants';
+import { Commands, isTestExecution, PYTHON, PYTHON_LANGUAGE, STANDARD_OUTPUT_CHANNEL } from './common/constants';
 import { registerTypes as registerDotNetTypes } from './common/dotnet/serviceRegistry';
 import { registerTypes as installerRegisterTypes } from './common/installer/serviceRegistry';
 import { traceError } from './common/logger';
@@ -85,7 +85,7 @@ import { registerTypes as interpretersRegisterTypes } from './interpreter/servic
 import { ServiceContainer } from './ioc/container';
 import { ServiceManager } from './ioc/serviceManager';
 import { IServiceContainer, IServiceManager } from './ioc/types';
-import { setLanguageConfiguration } from './language/languageConfiguration';
+import { getLanguageConfiguration } from './language/languageConfiguration';
 import { LinterCommands } from './linters/linterCommands';
 import { registerTypes as lintersRegisterTypes } from './linters/serviceRegistry';
 import { ILintingEngine } from './linters/types';
@@ -176,7 +176,7 @@ async function activateUnsafe(context: ExtensionContext): Promise<IExtensionApi>
  const linterProvider = new LinterProvider(context, serviceManager);
  context.subscriptions.push(linterProvider);
 
- setLanguageConfiguration();
+ languages.setLanguageConfiguration(PYTHON_LANGUAGE, getLanguageConfiguration());
 
  if (pythonSettings && pythonSettings.formatting && pythonSettings.formatting.provider !== 'internalConsole') {
  const formatProvider = new PythonFormattingEditProvider(context, serviceContainer);

src/client/language/languageConfiguration.ts

@@ -2,33 +2,111 @@
 // Licensed under the MIT License.
 'use strict';
 
-import { IndentAction, languages } from 'vscode';
-import { PYTHON_LANGUAGE } from '../common/constants';
+import { IndentAction, LanguageConfiguration } from 'vscode';
+import { verboseRegExp } from '../common/utils/regexp';
 
-export const MULTILINE_SEPARATOR_INDENT_REGEX = /^(?!\s+\\)[^#\n]+\\$/;
+// tslint:disable:no-multiline-string
 
-export function setLanguageConfiguration() {
- // Enable indentAction
- languages.setLanguageConfiguration(PYTHON_LANGUAGE, {
+// tslint:disable-next-line:max-func-body-length
+export function getLanguageConfiguration(): LanguageConfiguration {
+ return {
  onEnterRules: [
+ // multi-line separator
  {
- beforeText: /^\s*(?:def|class|for|if|elif|else|while|try|with|finally|except|async)\b.*:\s*/,
- action: { indentAction: IndentAction.Indent }
- },
- {
- beforeText: MULTILINE_SEPARATOR_INDENT_REGEX,
- action: { indentAction: IndentAction.Indent }
+ beforeText: verboseRegExp(`
+ ^
+ (?! \\s+ \\\\ )
+ [^#\n]+
+ \\\\
+ $
+ `),
+ action: {
+ indentAction: IndentAction.Indent
+ }
  },
+ // continue comments
  {
  beforeText: /^\s*#.*/,
  afterText: /.+$/,
- action: { indentAction: IndentAction.None, appendText: '# ' }
+ action: {
+ indentAction: IndentAction.None,
+ appendText: '# '
+ }
+ },
+ // indent on enter (block-beginning statements)
+ {
+ /**
+ * This does not handle all cases. However, it does handle nearly all usage.
+ * Here's what it does not cover:
+ * - the statement is split over multiple lines (and hence the ":" is on a different line)
+ * - the code block is inlined (after the ":")
+ * - there are multiple statements on the line (separated by semicolons)
+ * Also note that `lambda` is purposefully excluded.
+ */
+ beforeText: verboseRegExp(`
+ ^
+ \\s*
+ (?:
+ (?:
+ (?:
+ class |
+ def |
+ async \\s+ def |
+ except |
+ for |
+ if |
+ elif |
+ while |
+ with
+ )
+ \\b .*
+ ) |
+ else |
+ try |
+ finally
+ )
+ \\s*
+ [:]
+ \\s*
+ (?: [#] .* )?
+ $
+ `),
+ action: {
+ indentAction: IndentAction.Indent
+ }
  },
+ // outdent on enter (block-ending statements)
  {
- beforeText: /^\s+(continue|break|return)\b.*/,
- afterText: /\s+$/,
- action: { indentAction: IndentAction.Outdent }
+ beforeText: verboseRegExp(`
+ ^
+ (?:
+ (?:
+ \\s*
+ (?:
+ pass |
+ raise \\s+ [^#\\s] [^#]*
+ )
+ ) |
+ (?:
+ \\s+
+ (?:
+ raise |
+ break |
+ continue
+ )
+ )
+ )
+ \\s*
+ (?: [#] .* )?
+ $
+ `),
+ action: {
+ indentAction: IndentAction.Outdent
+ }
  }
+ // Note that we do not currently have an auto-dedent
+ // solution for "elif", "else", "except", and "finally".
+ // We had one but had to remove it (see issue #6886).
  ]
- });
+ };
 }

src/test/common/utils/regexp.unit.test.ts

@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+// tslint:disable:no-multiline-string
+
+import { expect } from 'chai';
+
+import {
+ verboseRegExp
+} from '../../../client/common/utils/regexp';
+
+suite('Utils for regular expressions - verboseRegExp()', () => {
+ test('whitespace removed in multiline pattern (example of typical usage)', () => {
+ const regex = verboseRegExp(`
+ ^
+ (?:
+ spam \\b .*
+ ) |
+ (?:
+ eggs \\b .*
+ )
+ $
+ `);
+
+ expect(regex.source).to.equal('^(?:spam\\b.*)|(?:eggs\\b.*)$', 'mismatch');
+ });
+
+ const whitespaceTests = [
+ ['spam eggs', 'spameggs'],
+ [`spam
+ eggs`, 'spameggs'],
+ // empty
+ [' ', '(?:)'],
+ [`
+ `, '(?:)']
+ ];
+ for (const [pat, expected] of whitespaceTests) {
+ test(`whitespace removed ("${pat}")`, () => {
+ const regex = verboseRegExp(pat);
+
+ expect(regex.source).to.equal(expected, 'mismatch');
+ });
+ }
+
+ const noopPatterns = [
+ '^(?:spam\\b.*)$',
+ 'spam',
+ '^spam$',
+ 'spam$',
+ '^spam'
+ ];
+ for (const pat of noopPatterns) {
+ test(`pattern not changed ("${pat}")`, () => {
+ const regex = verboseRegExp(pat);
+
+ expect(regex.source).to.equal(pat, 'mismatch');
+ });
+ }
+
+ const emptyPatterns = [
+ '',
+ `
+ `,
+ ' '
+ ];
+ for (const pat of emptyPatterns) {
+ test(`no pattern ("${pat}")`, () => {
+ const regex = verboseRegExp(pat);
+
+ expect(regex.source).to.equal('(?:)', 'mismatch');
+ });
+ }
+});