Movatterモバイル変換

[0]ホーム
URL:

Version 1.107 is now available! Read about the new features and fixes from November.

Dismiss this update

August 2024 (version 1.93)

Update 1.93.1: The update addresses theseissues.

Downloads: Windows:x64Arm64 | Mac:UniversalIntelsilicon | Linux:debrpmtarballArmsnap

Welcome to the August 2024 release of Visual Studio Code. There are many updates in this version that we hope you'll like, some of the key highlights include:

If you'd like to read these release notes online, go toUpdates oncode.visualstudio.com.Insiders: Want to try new features as soon as possible? You can download the nightlyInsiders build and try the latest updates as soon as they are available.

Accessibility

Resize table columns via the keyboard

A new command,list.resizeColumn, enables you to resize columns by using the keyboard. When you trigger this command, select the column you want to resize and provide a percentage of the width you want to set. The following video shows how to apply this to resize a column in the Keyboard Shortcuts editor.

Screen reader support for synthesizing chat responses

We've updated theaccessibility.voice.autoSynthesize setting to enable screen reader users to opt in to hearing chat responses announced by our synthesizer, instead of getting aria alerts.

Debugging improvements

When you're debugging with the focus in an editor, invoking theDebug: Add to Watch command now announces the variable's value for screen reader users.

Additionally, the Debug accessibility help dialog was improved for better thoroughness.

Workbench

New Profiles editor

The new Profiles editor is now generally available for all in Visual Studio Code. The new Profiles editor enables you to manage profiles from a single place. This experience includes creating new profiles, editing and deleting existing profiles, and importing and exporting profiles to share with others. For more information, see theProfiles documentation.

Screenshot that shows the Profiles editor.

Linux support for window control overlays

A new settingwindow.experimentalControlOverlay enables native window controls to appear, even when a custom title bar is enabled via thewindow.titleBarStyle setting.

Screenshot of VS Code on Linux, highlighting the Linux window control overlays in the top-right corner.

Out of the box, we have not yet enabled the custom title by default on Linux, but we plan to do so eventually. Once you turn on a custom title, native window control overlays will appear automatically. We welcome any feedback you find when using this new feature!

Comments sorting

Comments can now be sorted by their position in the file or by date.

Screenshot that shows the additional comment sorting options.

Copy settings URL from Settings editor

You can copy a direct URL to a specific setting from the Settings editor. When you navigate to the settings URL, it opens VS Code and focuses the corresponding setting in the Settings editor.

Video that shows how to copy a setting URL in the Settings editor.

Reverse sort in Explorer

We added an additional sort option,explorer.sortOrderReverse, which enables you to reverse any of the various Explorer sort configurations, providing further sorting flexibility.

Editor

Lightbulb improvements

In the previous milestone, we improved the location where the Code Actions lightbulb icon is shown. We've now decided to seteditor.lightbulb.enabled toonCode by default. This means that the lightbulb icon is only shown when the cursor is on lines with source code and will show up less frequently.

Color theming for action lists

The color of the action list control, such as the Code Action menu, can be configured by themes with theeditorActionList.background,editorActionList.foreground,editorActionList.focusForeground, andeditorActionList.focusBackground keys. By default, the action list control theme matches that of the Quick Pick and Command Palette. Get more info aboutcustomizing a color theme.

GitHub Copilot

This milestone, we continued to improve the GitHub Copilot experience in VS Code, across the editor, the Chat view, and inline Chat. We've also added several experimental features for you to try and for which we'd like to get your feedback.

Improved test generation

With GitHub Copilot, you can generate tests for your code, either by using theGenerate Tests using Copilot action in the editor content menu, or by using the/tests slash command in inline Chat.

We improved the test generation flow by looking for an existing test file and generating the new tests into that file, appending them at the end. If there isn't a test file yet, Copilot creates a new test file for the generated tests.

Renamed Code Actions for generating tests and documentation

When you place the cursor on an identifier, such as a method name, GitHub Copilot gives you Code Actions to generate tests or documentation. To better reflect their purpose, we renamed these Code Actions toGenerate Tests using Copilot andGenerate Documentation using Copilot. Previously, these were calledTest using Copilot andDocument using Copilot.

New code action names for test and documentation generation

Improved chat history

You can open previous chat sessions from the chat history with theShow Chats button at the top of the Chat view. These sessions now have a more user-friendly, AI-generated name. You can also rename sessions manually by selecting the pencil icon on each row.

These chat history entries are now also sorted by the date of their last request, and are labeled and grouped by date buckets.

The chat history picker shows friendly session names and entries are grouped by age.

Note: Only new chat sessions get the AI-generated name, any chat sessions that you already had won't be renamed.

Save chat sessions for empty windows

Previously, VS Code wasn't saving chat sessions for empty windows (that don't have a folder or workspace open). Now, these sessions are saved as expected, and previous chats from an empty window can be loaded via theShow Chats button.

Note: You should avoid opening and using the same chat session in multiple empty windows simultaneously.

Attach context in Quick Chat

When using Quick Chat, you can now use theAttach Context action to attach context like files and symbol to your Copilot request.

Thumbs down feedback details

Did you get a response from Copilot Chat that wasn't what you expected? Help us out by selecting theThumbs down button on the toolbar for a chat response. Now, it shows a dropdown with a few detailed options for you to describe the issue. You can also open the issue reporter from this menu.

The chat response feedback dropdown, showing extra details on the thumbs down button.

Code generation instructions (Experimental)

Setting:github.copilot.chat.experimental.codeGeneration.instructions

Copilot can help you generate code, for example as part of a refactoring, generating unit tests, or implementing a feature. And you might have specific libraries you want to use, or a particular coding style you want to follow for the code that Copilot generates.

The experimental settinggithub.copilot.chat.experimental.codeGeneration.instructions lets you define a set of instructions that are added to every Copilot request that generates code.

The instructions can be defined in the User or Workspacesettings but can also be imported from a file.

The following code snippet shows how to define a set of instructions from both settings and an external file:

  "github.copilot.chat.experimental.codeGeneration.instructions": [    {      "text":"Always add a comment: 'Generated by Copilot'."    },    {      "text":"In TypeScript always use underscore for private field names."    },    {      "file":"code-style.md" // import instructions from file `code-style.md`    }  ],

Content ofmyProject/code-style.md:

Always use React functional components.Always add comments.

In the screenshot, you can see from the references section that the instructions were used:

Copilot Chat using code generation instructions.

Automatic chat participant detection in Chat view (Experimental)

Setting:chat.experimental.detectParticipant.enabled

GitHub Copilot has several built-in chat participants, such as@workspace, which also contribute commands to the Chat view. Previously, you had to explicitly specify the chat participant and command in a chat prompt.

To make it easier to use chat participants with natural language, in the coming weeks, we're experimenting with enabling Copilot Chat to automatically route your question to a suitable participant or chat command.

Screenshot of Chat view that shows how the '@workspace' participant is automatically detected.

If the automatically selected participant is not appropriate for your question, you can select thererun without link at the top of the chat response to resend your question to Copilot.

Use recent coding files as Inline Chat context (Experimental)

Setting:github.copilot.chat.experimental.temporalContext.enabled

Often, when you're prompting Copilot, you're asking a question related to code you were just working on or looking at. Inline Chat can now use recently seen or edited code as context to provide more relevant suggestions.

This functionality is still experimental but also good to be tested by everyone.

Use current editor line as inline Chat prompt (Experimental)

Setting:github.copilot.config.experimental.inlineChatCompletionTrigger.enabled

Instead of first opening inline Chat and then entering your chat prompt, you can now start typing in the editor and use the contents of the current line directly as the prompt for inline Chat. And for an even smoother chat experience, Copilot can detect when you're prompting instead of writing code, and then automatically start inline Chat for you.

The different ways in which you can use the current line as your prompt for inline Chat are the following:

  • EnterInline Chat: Start in Editor with Current Line from theCommand Palette (⇧⌘P (Windows, LinuxCtrl+Shift+P))
  • Configure a keybinding for theinlineChat.startWithCurrentLine command, combine it with theinlineChatExpansion context key
  • Enable thegithub.copilot.config.experimental.inlineChatCompletionTrigger.enabled setting, so that Copilot detects that the current line has mostly text instead of source code, and then starts inline Chat.

The following video shows how Copilot suggests starting inline Chat after it detects that there's mostly text on the current line.

Start debugging from Chat (Experimental)

Setting:github.copilot.advanced.startDebugging.experimental.enabled

A new experimental slash command,/startDebugging, is available on the@vscode chat participant. This command enables you to create a launch configuration and start debugging your app.

You can also access this command through theGenerate Debug Configuration with GitHub Copilot option in the Create a launch.json Quick Pick.

Generate Debug Configuration with GitHub Copilot is an option in the Create a launch.json file Quick Pick.

Generate tests based on test coverage (Experimental)

Setting:github.copilot.chat.experimental.generateTests.codeLens

If test coverage information is available, GitHub Copilot can offer a CodeLensGenerate tests using Copilot for functions and methods that are not yet covered by tests.

Languages

Renamed "SQL" to "MS SQL"

The language name for SQL files has been renamed from "SQL" to "MS SQL" to better reflect the language's focus on Microsoft SQL Server (T-SQL) syntax. The file extension for this language mode is still.sql and the syntax highlighting remains unchanged.

Full project Intellisense and package typings on vscode.dev

Working with JavaScript and TypeScript onVS Code for the Web just got a whole lot better. To start off, we've implemented package IntelliSense, so you can see suggestions and documentation from any imported package, such asreact. This works much like it does in the desktop version of VS Code.

IntelliSense and error reporting for an imported package on vscode.dev.

In TypeScript files, we offer IntelliSense for packages listed in yourpackage.json. JavaScript files are a little more flexible and useautomatic type acquisition, which offers IntelliSense for any package imported into the current file, even if it's not listed in thepackage.json.

Thanks to package IntelliSense, we've also enabled full project IntelliSense for JavaScript and TypeScript projects. This greatly improves navigation through code, letting you correctlyGo to Definition andFind All References to any symbol in your project. It also enables type error reporting. We now even support auto-imports while writing code.

Finding all references of a symbol in a TypeScript project.

Package typings and full project IntelliSense are supported in Chrome, Microsoft Edge, and Firefox. Safari is not yet supported, as it does not implementReadableByteStreamController.

Source Control

Source Control Graph view

Based on user feedback, we have moved the history graph that was enabled last milestone from the Source Control view into a new view calledSource Control Graph. This reduces the information overload from the main view and enables you to hide/collapse/move the new view as you see fit. This also lays the foundation for a full-featured history graph.

The Source Control Graph view currently shows the remote/base for the current branch. In the next milestone, we are working on adding the capability to filter the graph to any repository reference, and improving the experience for workspaces with multiple repositories.

Source Control Graph view showing a graph visualization of the repository.

Theme:GitHub Sharp (preview onvscode.dev)

Support for reftable format

Git 2.45 added preliminary support for the new reference storage backend called "reftable". This milestone, we updated the built-in Git extension to support this new reference storage backend.

Using Git 2.45, you can either create or clone a repository that uses the new reference storage backend with the--ref-format=reftable flag. Git 2.46 also added support for migrating an existing repository to use the new reference storage format by using thegit refs migrate command.

Please note that the new reference storage backend is still considered experimental.

Compact folders setting

Thanks to a community contribution, we have added a new setting,scm.compactFolders, to control whether folders are rendered in compact form in the Source Control view when changes are viewed as a tree.

Terminal

Julia and NuShell support

There's now shell integration support for Julia and NuShell. This enables features such ascommand decorations andrun recent command for these shell types.

Move multiple terminal tabs

You can now multi-select terminal tabs and move them around the list of terminals as an ordered group.

Command guide setting and color theming

The command guide is a bar that shows up beside a command and its output when hovered. You can now disable thecommand guide with theterminal.integrated.shellIntegration.showCommandGuide setting and the color can be configured by themes with theterminalCommandGuide.foreground theme key.

Notebooks

Show or hide unchanged cells in the diff view

The notebook diff view now hides unchanged cells, which enables you to focus on the changed cells.At the same time, the input of all unchanged cells is always collapsed.

Manage whitespace in the diff view

The notebook diff view now respects the following setting:

Sticky Scrolling for Notebook execution count

The execution count of a code cell now sticks to the bottom of the screen when scrolling down a code cell. This makes it easier to see the execution state and update when working in a long code cell.

Tasks

Keep task terminal open on process exit

If a task's terminal process exits with a nonzero code, we now keep the terminal open for easier debugging.

Debug

Jump to variable definition

Debug extensions can now link variables and expressions to locations in your code. Data with this link areCtrl-selectable (Cmd-selectable on macOS) in the Variables view, Watch view, and Debug Console.

The built-in JavaScript debugger will link locations of functions defined in your code¸ Other debug extensions need to adopt the corresponding protocol change to enable this feature.

Find control

You can now open the Find control in the Debug Console (⌥⌘F (Windows, LinuxCtrl+Alt+F)) to search for results in the input. Support for searching results in the output will be investigated in future milestones.

You can also access the control via the actionDebug Console: Focus Find that appears on the Debug Console's toolbar to the right of the Filter control.

Launch config input cache

Input variables used in launch configurations and tasks now persist their last entered value to ease the process of rerunning debug sessions that depend on them. This is only done if there is no explicitdefault defined on the input.

JavaScript Debugger

Experimental Network view

The JavaScript debugger now includes a basic, experimental Network view that is available when thedebug.javascript.enableNetworkView setting is turned on. The view displays information about requests and responses made by browser sessions.

Screenshot that shows the Network view for the JavaScript debugger.Theme:Codesong (preview onvscode.dev)

The Network view also works for Node.js 22.6.0 and above when the process is launched with--experimental-network-inspection in its arguments, such as by adding"runtimeArgs": ["--experimental-network-inspection"] into anode launch configuration.

Note: Node's implementation of networking is still very early and most data around requests and responses is not yet available.

Testing

Support for stack traces on messages

Testing extensions can now associate a stack trace with test failures. When they do, you'll see the code around each frame of the call stack in the Test Results view and in error peeks. You canCtrl-select (Cmd-select on macOS) on code in the views to go to their original locations, or use theGo to File action on their headers.

Editor showing a test failure message and the corresponding call stack that led to the failure.Theme:Codesong (preview onvscode.dev)

Installer

The Debian package now prompts you to confirm whether you want to add thepackages.microsoft.com repository. This enables you to update the package afterwards by using apt.

Terminal showing the prompt for adding the Microsoft packages repo during the install.

Remote Development

TheRemote Development extensions, allow you to use aDev Container, remote machine via SSH orRemote Tunnels, or theWindows Subsystem for Linux (WSL) as a full-featured development environment.

Highlights include:

  • Optional paths for Dev Container Templates
  • Expanded compatibility for remote OSes with SSH

You can learn more about these features in theRemote Development release notes.

VS Code for the Web

Thegit.openDiffOnClick setting is now honored when browsing a GitHub repository onhttps://vscode.dev or on the desktop with theGitHub Repositories extension.

Open diff by selecting Open Changes for changed resources.

Contributions to extensions

Python

Django unit test support

We are excited to announce support for one of our mostrequested features: you can now discover and run Django unit tests through the Test Explorer! For set up instructions on how to enable this functionality,check our documentation.

Django unit tests discovered and run in the Test Explorer.Theme:Catppuccin Macchiato (preview onvscode.dev)

As you explore this newly added feature, please provide feedback and report any issues in ourvscode-python repo or by using thePython: Report Issue command.

Native REPL improvements

We made more improvements and bug fixes to the new Native REPL experience. We are rolling out the native REPL as the default target forSmart Send as an experiment, but if you are interested in trying this out, you can setpython.REPL.sendToNativeREPL in your Usersettings.json and reload your VS Code window.

Go to definition from inlay hints with Pylance

Wheninlay hints are enabled with Pylance, you can now more conveniently navigate to a type's definition by hovering over it and clicking while holdingCtrl (Cmd on macOS):

Go to Definition supported by using Ctrl/Cmd + click when hovering over a Python type on an inlay hint.

Restart support when debugging tests

You can now restart the debugger when debugging tests through the Debug toolbar control.

GitHub Pull Requests and Issues

There has been more progress on theGitHub Pull Requests extension, which enables you to work on, create, and manage pull requests and issues. Review thechangelog for the 0.96.0 release of the extension to learn about the highlights.

Extension authoring

Impact of EcmaScript Module (ESM) Loading of VS Code

We are in the process of changing how our code is loaded in VS Code core, away from AMD/CommonJS to ESM. Extensions will continue to load as CommonJS, but this change comes with change to therequire method: Specifically,require.main will beundefined beginning with our1.94 release. If you have a usecase for accessing a file from the installation, please considervscode.env.appRoot instead orreach out to us.

Terminal shell integration API

The terminal shell integration API is now available to use. This powerful API enables an extension to listen to commands run in terminals, read their raw output, exit code, and command lines.

window.onDidEndTerminalShellExecution(event => {  if (event.execution.commandLine.value.startsWith('git')) {    if (event.exitCode ===0) {      // React to a successful git command    }else {      // React to a failing git command    }  }});

It also provides a more reliable way to execute a command, which will wait for a prompt to start before sending the command, preventing the command to be echoed to the terminal an extra time.

const commandLine ='echo "Hello world"';if (term.shellIntegration) {  const execution =shellIntegration.executeCommand({commandLine });  window.onDidEndTerminalShellExecution(event => {    if (event.execution ===execution) {      console.log(`Command exited with code${event.exitCode}`);    }  });}else {  term.sendText(commandLine);  // Without shell integration, we can't know when the command has finished or what the  // exit code was.}

See the API invscode.d.ts and theextension sample for more information.

Authentication account API

The authentication APIs now have more control when handling multiple accounts. Something that has always been missing is the ability to get all accounts and get anAuthenticationSession for a specific account. That is now possible with the finalization of thegetAccounts API.

Extension authors looking to consume authentication sessions can run the following code to get theAuthenticationSessionAccountInformation of the accounts that the user is logged into:

const accounts =vscode.authentication.getAccounts('microsoft');

From there, you can use those accounts to mint sessions specifically for those accounts:

const session =vscode.authentication.getSession('microsoft',scopes, {  account: accounts[0]});

Note: For this to work, the authentication provider needs to handle a parameter that is passed in to bothgetSessions andcreateSession. The built-in GitHub and Microsoft providers have already adopted this.

We believe that this is the clearest way to handle multiple authentication sessions and also handle various scenarios that we couldn't support before.

Debug Adapter Protocol

We addedlocationReferences to Variables and other data types in theDebug Adapter Protocol, to enable associating a source location.

WebAssemblies in VS Code

The 1.0 versions of thewasm-wasi-core extension together with the@vscode-wasm-wasi and@vscode/wasm-component-model npm modules have been released. Usage samples can be found in thevscode-extension-samples repository in thewasm-* sub folders. There are also several posts about how to use WebAssembly code inside a VS Code extension on theVS Code blog.

Preview Features

Terminal IntelliSense improvements

Experimental PowerShell IntelliSense got the following improvements this release:

  • git checkout now includes a completion for- to switch to the previous branch.
  • The default value forterminal.integrated.suggest.runOnEnter is now set to ignore, which meansEnter does not interact at all with IntelliSense. This was feedback from users who found the impact on muscle memory too disruptive.
  • PowerShell keywords are now available as completions for the command (not args).
  • Thecd first directory suggestion is now always itself, which makes things smoother whenterminal.integrated.suggest.runOnEnter is set.cd into docs will present docs as the top result.
  • Suggestions are more consistent now when requested at different positions on the command line.
  • A completion is provided for<path>/../ when navigating back directories.cd ..\ will give a suggestion for ..\..\.

Conpty shipping in product

Conpty is the backend for the terminal that emulates how pseudoterminals work on other operating systems. This component is shipped in Windows itself, which means that bug fixes are released via Windows Update. Users might end up waiting a long time for these fixes to arrive.

This release, we have an experimental setting that bundles conpty with VS Code itself, similar to how Windows Terminal does it. This means that users can get bug fixes as we ship updates to VS Code instead of waiting on Windows updates.

To enable this, set the following setting totrue:

"terminal.integrated.experimental.windowsUseConptyDll":true

The type of improvements you should expect for enabling this are:

  • Better performance
  • More reliable shell integration
  • More escape sequence support (for examplesixel support on Windows soon)

The only currently known issue is that some users have a process that sticks around and blocks VS Code updates (microsoft/vscode#225719), which requires manually killing the process to enable updates.

TypeScript 5.6 support

We continued improving our support for the upcoming TypeScript 5.6 release. Check out theTypeScript 5.6 RC blog post for details on what this release includes.

To start using preview builds of TypeScript 5.6, install theTypeScript Nightly extension.

New Issue Reporter implementation

This milestone, we are experimenting with a new implementation of the Issue Reporter. The functionality remains the same, but there should be a few improvements, such as improved multi-monitor support, and the availability of the Issue Reporter in VS Code for the Web.

The new version of the Issue Reporter is enabled by default and can be configured with theissueReporter.experimental.auxWindow setting in desktop versions of VS Code.

Proposed APIs

Tools for language models

We continue to iterate on ourLanguageModelTool API. The API comes with two major parts:

  1. The ability for extensions to register atool. A tool is a piece of functionality that is meant to be used by language models. For example, reading the Git history of a file.

  2. The mechanics for language models to support tools, such as extensions passing tools when making a request, language models requesting a tool invocation, and extensions communicating back the result of a tool invocation.

One of the changes this month adds is the ability for the user to manually attach certain tools to their chat request. An example of this would be for a tool that computes some dynamic context that the user wants to use in their request.

The proposal can be found asvscode.proposed.lmTools.d.ts. Check out thetool-user sample extension that demonstrates registering and calling tools.

Watchissue #213274 for updates or to give us feedback.

Note: The API is still under active development, and things will change.

Testing enhancements

Associate code to tests

We're working on an API that enables an extension to associate code to tests, and vice versa. This lets users jump between both, and enables actions, such asRun Tests at Cursor, to also work in implementation code. We anticipate building more experiences as the API develops.

Check outvscode#126932 for more information and updates.

Attributable test coverage

We're working on an API for attributing test coverage on a per-test basis. This enables users to see which tests ran which code, filtering both the coverage shown in the editor, and that in theTest Coverage view.

Check outvscode#212196 for more information and updates.

Chat participant detection API

If you're authoring an extension that contributes participants or chat commands to the Chat view, you can enable your participants and commands to be automatically detected by adding metadata to yourchatParticipants contribution inpackage.json. We have updated thevscode-extension-samples repo withexamples of how you can adopt this API. When testing, be sure to setchat.experimental.detectParticipant.enabled. Please note that this is a proposed API that is subject to change.

Website

We have fixed several links under theVS Code API page. Links to generic types and functions work again, and primitive types and values aren't formatted as links anymore!

Engineering

Progress on using ESM for VS Code

During this milestone, we completed most of the work to adopt ESM for VS Code Core. Our goal is to use ECMAScript Modules (ESM) loading and drop AMD entirely. We will start to release ESM-enabled Insider builds in September and plan to ship ESM to Stable for our next release in October.

Our plan for releasing ESM is captured in https://github.com/microsoft/vscode/issues/226260.

Notable fixes

Thank you

Last but certainly not least, a bigThank You to the contributors of VS Code.

Issue tracking

Contributions to our issue tracking:

Pull requests

Contributions tovscode:

Contributions tovscode-css-languageservice:

Contributions tovscode-eslint:

Contributions tovscode-flake8:

Contributions tovscode-generator-code:

Contributions tovscode-hexeditor:

Contributions tovscode-isort:

Contributions tovscode-js-profile-visualizer:

Contributions tovscode-json-languageservice:

Contributions tovscode-languageserver-node:

Contributions tovscode-loader:

Contributions tovscode-mypy:

Contributions tovscode-pull-request-github:

Contributions tovscode-python-debugger:

Contributions tovscode-vsce:

Contributions tolanguage-server-protocol:

Contributions topython-environment-tools:

    [8]ページ先頭
    ©2009-2025 Movatter.jp