falsepattern/ZigBrains
1
0
Fork 0
Code Issues Pull requests Projects Releases 2 Packages Wiki Activity

backport: 12.1.0-pre01

Browse source
This commit is contained in:
FalsePattern 2024-03-04 01:53:52 +01:00
parent b8a448d7fe
commit ff29b663dc
Signed by: falsepattern
GPG key ID: E930CDEC50C50E23
65 changed files with 1547 additions and 730 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
CHANGELOG.md
View file

@ -18,6 +18,26 @@ Changelog structure reference:
## [Unreleased]
### Added
- Debugging
- Debugging support for tests when launched using the ZigTest task type (and with the gutter icons in the editor)
- Project
- Added `zig init` as a new project creation option
- New projects will now have the project name in the build files instead of "untitled"
- Zig
- Updated semantic highlighting to latest ZLS protocol
### Fixed
- Project
- Fixed build.zig and build.zig.zon getting placed in src/ during project creation
- Plugin
- Removed a bunch of write action locking, the editor should feel more responsive now
## [12.0.0]
### Added

28
build.gradle.kts
View file

@ -1,10 +1,7 @@
import groovy.xml.XmlParser
import org.jetbrains.changelog.Changelog
import org.jetbrains.changelog.markdownToHTML
import org.jetbrains.grammarkit.tasks.GenerateLexerTask
import org.jetbrains.grammarkit.tasks.GenerateParserTask
import org.jetbrains.intellij.tasks.PatchPluginXmlTask
import org.jetbrains.intellij.tasks.RunPluginVerifierTask
fun properties(key: String) = providers.gradleProperty(key)
fun environment(key: String) = providers.environmentVariable(key)
@ -15,8 +12,11 @@ plugins {
id("org.jetbrains.intellij") version("1.17.2")
id("org.jetbrains.changelog") version("2.2.0")
id("org.jetbrains.grammarkit") version("2022.3.2.2")
id("com.palantir.git-version") version("3.0.0")
}
val gitVersion: groovy.lang.Closure<String> by extra
val grammarKitGenDir = "build/generated/sources/grammarkit/java"
val rootPackage = "com.falsepattern.zigbrains"
@ -43,8 +43,20 @@ tasks {
}
}
fun getPluginVersionFull(): Provider<String> {
return properties("pluginVersion").map { it + "-" + properties("pluginSinceBuild").get() }
fun pluginVersion(): Provider<String> {
return provider {
System.getenv("RELEASE_VERSION")
}.orElse(provider {
try {
gitVersion()
} catch (_: java.lang.Exception) {
error("Git version not found and RELEASE_VERSION environment variable is not set!")
}
})
}
fun pluginVersionFull(): Provider<String> {
return pluginVersion().map { it + "-" + properties("pluginSinceBuild").get() }
}
allprojects {
@ -86,7 +98,7 @@ allprojects {
}
group = properties("pluginGroup").get()
version = getPluginVersionFull().get()
version = pluginVersionFull().get()
tasks {
runIde { enabled = false }
@ -303,7 +315,7 @@ project(":plugin") {
}
patchPluginXml {
version = getPluginVersionFull()
version = pluginVersionFull()
// Extract the <!-- Plugin description --> section from README.md and provide for the plugin's manifest
pluginDescription = providers.fileContents(rootProject.layout.projectDirectory.file("README.md")).asText.map {
@ -320,7 +332,7 @@ project(":plugin") {
val changelog = rootProject.changelog // local variable for configuration cache compatibility
// Get the latest available change notes from the changelog file
changeNotes = properties("pluginVersion").map { pluginVersion ->
changeNotes = pluginVersion().map { pluginVersion ->
with(changelog) {
renderItem(
(getOrNull(pluginVersion) ?: getUnreleased())

2
gradle.properties
View file

@ -1,8 +1,6 @@
pluginGroup = com.falsepattern.zigbrains
pluginName = ZigBrains
pluginRepositoryUrl = https://github.com/FalsePattern/ZigBrains
# SemVer format -> https://semver.org
pluginVersion = 12.0.0
# Supported build number ranges and IntelliJ Platform versions -> https://plugins.jetbrains.com/docs/intellij/build-number-ranges.html
pluginSinceBuild = 232

32
modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/ZigDebugRunner.java
View file

@ -1,32 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.zig.debugger;
import com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfiguration;
import com.falsepattern.zigbrains.project.openapi.components.ZigProjectSettingsService;
import com.falsepattern.zigbrains.project.toolchain.LocalZigToolchain;
import com.intellij.execution.configurations.RunProfile;
import org.jetbrains.annotations.NotNull;
public class ZigDebugRunner extends ZigDebugRunnerBase {
@Override
public boolean canRun(@NotNull String executorId, @NotNull RunProfile profile) {
return super.canRun(executorId, profile) &&
(profile instanceof ZigRunExecutionConfiguration $prof) &&
(ZigProjectSettingsService.getInstance($prof.getProject()).getToolchain() instanceof LocalZigToolchain);
}
}

4
modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/ZigDebuggerLanguageSupport.java
View file

@ -16,7 +16,7 @@
package com.falsepattern.zigbrains.zig.debugger;
import com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfiguration;
import com.falsepattern.zigbrains.project.execution.base.ZigExecConfigBase;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.xdebugger.evaluation.XDebuggerEditorsProvider;
import com.jetbrains.cidr.execution.debugger.CidrDebuggerLanguageSupport;
@ -34,7 +34,7 @@ public class ZigDebuggerLanguageSupport extends CidrDebuggerLanguageSupport {
@Override
public @Nullable XDebuggerEditorsProvider createEditor(@Nullable RunProfile profile) {
if (!(profile instanceof ZigRunExecutionConfiguration)) {
if (!(profile instanceof ZigExecConfigBase<?>)) {
return null;
}
return createEditorProvider();

17
modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/ZigDebugRunParameters.java → modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/base/ZigDebugParametersBase.java
View file

@ -14,12 +14,11 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.zig.debugger;
package com.falsepattern.zigbrains.zig.debugger.base;
import com.intellij.execution.configurations.GeneralCommandLine;
import com.jetbrains.cidr.execution.Installer;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.falsepattern.zigbrains.project.toolchain.AbstractZigToolchain;
import com.jetbrains.cidr.execution.RunParameters;
import com.jetbrains.cidr.execution.TrivialInstaller;
import com.jetbrains.cidr.execution.debugger.backend.DebuggerDriverConfiguration;
import lombok.RequiredArgsConstructor;
import org.jetbrains.annotations.NotNull;
@ -27,14 +26,10 @@ import org.jetbrains.annotations.Nullable;
@RequiredArgsConstructor
public class ZigDebugRunParameters extends RunParameters {
private final GeneralCommandLine cmd;
public abstract class ZigDebugParametersBase<ProfileState extends ProfileStateBase<?>> extends RunParameters {
private final DebuggerDriverConfiguration driverConfiguration;
@Override
public @NotNull Installer getInstaller() {
return new TrivialInstaller(cmd);
}
protected final AbstractZigToolchain toolchain;
protected final ProfileState profileState;
@Override
public @NotNull DebuggerDriverConfiguration getDebuggerDriverConfiguration() {

34
modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/ZigDebugRunnerBase.java → modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/base/ZigDebugRunnerBase.java
View file

@ -14,12 +14,15 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.zig.debugger;
package com.falsepattern.zigbrains.zig.debugger.base;
import com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfigurationRunProfileState;
import com.falsepattern.zigbrains.project.runconfig.ZigExecutableRunner;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.falsepattern.zigbrains.project.runconfig.ZigProgramRunnerBase;
import com.falsepattern.zigbrains.project.toolchain.AbstractZigToolchain;
import com.falsepattern.zigbrains.zig.debugger.Utils;
import com.falsepattern.zigbrains.zig.debugger.ZigLocalDebugProcess;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.configurations.GeneralCommandLine;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.execution.executors.DefaultDebugExecutor;
import com.intellij.execution.process.ProcessTerminatedListener;
import com.intellij.execution.runners.ExecutionEnvironment;
@ -31,19 +34,18 @@ import com.intellij.xdebugger.XDebugProcess;
import com.intellij.xdebugger.XDebugProcessStarter;
import com.intellij.xdebugger.XDebugSession;
import com.intellij.xdebugger.XDebuggerManager;
import com.jetbrains.cidr.execution.debugger.backend.DebuggerDriverConfiguration;
import lombok.val;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
public class ZigDebugRunnerBase extends ZigExecutableRunner {
public abstract class ZigDebugRunnerBase<ProfileState extends ProfileStateBase<?>> extends ZigProgramRunnerBase<ProfileState> {
public ZigDebugRunnerBase() {
super(DefaultDebugExecutor.EXECUTOR_ID, "Unable to run Zig debugger");
super(DefaultDebugExecutor.EXECUTOR_ID);
}
@Override
protected RunContentDescriptor showRunContent(ZigRunExecutionConfigurationRunProfileState state, ExecutionEnvironment environment, GeneralCommandLine runExecutable)
protected RunContentDescriptor doExecute(ProfileState state, AbstractZigToolchain toolchain, ExecutionEnvironment environment)
throws ExecutionException {
val project = environment.getProject();
val debuggerDriver = Utils.getDebuggerConfiguration(project);
@ -51,7 +53,11 @@ public class ZigDebugRunnerBase extends ZigExecutableRunner {
Notifications.Bus.notify(new Notification("ZigBrains.Debugger.Error", "Couldn't find a working GDB or LLDB debugger! Please check your Toolchains! (Settings | Build, Execution, Deployment | Toolchains)", NotificationType.ERROR));
return null;
}
val runParameters = new ZigDebugRunParameters(runExecutable, debuggerDriver);
val runParameters = getDebugParameters(state, environment, debuggerDriver, toolchain);
if (runParameters == null) {
//Assume that getDebugParameters reports the bug in a notification already
return null;
}
val manager = XDebuggerManager.getInstance(project);
return manager.startSession(environment,
new XDebugProcessStarter() {
@ -66,7 +72,7 @@ public class ZigDebugRunnerBase extends ZigExecutableRunner {
}
@Override
public @NotNull @NonNls String getRunnerId() {
return "ZigDebugRunner";
}
public abstract boolean canRun(@NotNull String executorId, @NotNull RunProfile profile);
protected abstract @Nullable ZigDebugParametersBase<ProfileState> getDebugParameters(ProfileState state, ExecutionEnvironment environment, DebuggerDriverConfiguration debuggerDriver, AbstractZigToolchain toolchain);
}

36
modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/run/ZigDebugParametersRun.java Normal file
View file

@ -0,0 +1,36 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.zig.debugger.run;
import com.falsepattern.zigbrains.project.execution.run.ProfileStateRun;
import com.falsepattern.zigbrains.project.toolchain.AbstractZigToolchain;
import com.falsepattern.zigbrains.zig.debugger.base.ZigDebugParametersBase;
import com.jetbrains.cidr.execution.Installer;
import com.jetbrains.cidr.execution.TrivialInstaller;
import com.jetbrains.cidr.execution.debugger.backend.DebuggerDriverConfiguration;
import org.jetbrains.annotations.NotNull;
public class ZigDebugParametersRun extends ZigDebugParametersBase<ProfileStateRun> {
public ZigDebugParametersRun(DebuggerDriverConfiguration driverConfiguration, AbstractZigToolchain toolchain, ProfileStateRun profileState) {
super(driverConfiguration, toolchain, profileState);
}
@Override
public @NotNull Installer getInstaller() {
return new TrivialInstaller(profileState.getCommandLine(toolchain));
}
}

60
modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/run/ZigDebugRunnerRun.java Normal file
View file

@ -0,0 +1,60 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.zig.debugger.run;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.falsepattern.zigbrains.project.execution.run.ProfileStateRun;
import com.falsepattern.zigbrains.project.execution.run.ZigExecConfigRun;
import com.falsepattern.zigbrains.project.toolchain.AbstractZigToolchain;
import com.falsepattern.zigbrains.project.toolchain.LocalZigToolchain;
import com.falsepattern.zigbrains.zig.debugger.base.ZigDebugRunnerBase;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.notification.Notification;
import com.intellij.notification.NotificationType;
import com.intellij.notification.Notifications;
import com.jetbrains.cidr.execution.debugger.backend.DebuggerDriverConfiguration;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class ZigDebugRunnerRun extends ZigDebugRunnerBase<ProfileStateRun> {
@Override
public boolean canRun(@NotNull String executorId, @NotNull RunProfile profile) {
return this.executorId.equals(executorId) &&
(profile instanceof ZigExecConfigRun);
}
@Override
public @NotNull @NonNls String getRunnerId() {
return "ZigDebugRunnerRun";
}
@Override
protected ZigDebugParametersRun getDebugParameters(ProfileStateRun profileStateRun, ExecutionEnvironment environment, DebuggerDriverConfiguration debuggerDriver, AbstractZigToolchain toolchain$) {
if (!(toolchain$ instanceof LocalZigToolchain toolchain)) {
Notifications.Bus.notify(new Notification("ZigBrains.Debugger.Error", "The debugger only supports local zig toolchains!", NotificationType.ERROR));
return null;
}
return new ZigDebugParametersRun(debuggerDriver, toolchain, profileStateRun);
}
@Override
protected @Nullable ProfileStateRun castProfileState(ProfileStateBase<?> state) {
return state instanceof ProfileStateRun state$ ? state$ : null;
}
}

100
modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/test/ZigDebugParametersTest.java Normal file
View file

@ -0,0 +1,100 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.zig.debugger.test;
import com.falsepattern.zigbrains.project.execution.test.ProfileStateTest;
import com.falsepattern.zigbrains.project.toolchain.AbstractZigToolchain;
import com.falsepattern.zigbrains.project.util.CLIUtil;
import com.falsepattern.zigbrains.zig.debugger.base.ZigDebugParametersBase;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.configurations.GeneralCommandLine;
import com.intellij.execution.process.ProcessEvent;
import com.intellij.execution.process.ProcessListener;
import com.jetbrains.cidr.execution.Installer;
import com.jetbrains.cidr.execution.debugger.backend.DebuggerDriverConfiguration;
import lombok.val;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Set;
import java.util.stream.Collectors;
public class ZigDebugParametersTest extends ZigDebugParametersBase<ProfileStateTest> {
public ZigDebugParametersTest(DebuggerDriverConfiguration driverConfiguration, AbstractZigToolchain toolchain, ProfileStateTest profileState) {
super(driverConfiguration, toolchain, profileState);
}
@Override
public @NotNull Installer getInstaller() {
return new ZigTestInstaller();
}
private class ZigTestInstaller implements Installer {
private File executableFile;
@Override
public @NotNull GeneralCommandLine install() throws ExecutionException {
val commandLine = profileState.getCommandLine(toolchain);
final Path tmpDir;
try {
tmpDir = Files.createTempDirectory("zigbrains_debug").toAbsolutePath();
} catch (IOException e) {
throw new ExecutionException("Failed to create temporary directory for test binary", e);
}
val exe = tmpDir.resolve("executable").toFile();
commandLine.addParameters("--test-no-exec", "-femit-bin=" + exe.getAbsolutePath());
val outputOpt = CLIUtil.execute(commandLine, Integer.MAX_VALUE);
if (outputOpt.isEmpty()) {
throw new ExecutionException("Failed to start \"zig test\"!");
}
val output = outputOpt.get();
if (output.getExitCode() != 0) {
throw new ExecutionException("Zig test compilation failed with exit code " + output.getExitCode() + "\nError output:\n" + output.getStdout() + "\n" + output.getStderr());
}
//Find our binary
try (val stream = Files.list(tmpDir)){
executableFile = stream.filter(file -> !file.getFileName().toString().endsWith(".o"))
.map(Path::toFile)
.filter(File::canExecute)
.findFirst()
.orElseThrow(() -> new IOException("No executable file present in temporary directory \"" +
tmpDir + "\""));
} catch (Exception e) {
throw new ExecutionException("Failed to find compiled test binary", e);
}
//Construct new command line
val cfg = profileState.configuration();
val cli = new GeneralCommandLine().withExePath(executableFile.getAbsolutePath());
if (cfg.workingDirectory != null) {
cli.withWorkDirectory(cfg.workingDirectory.toString());
}
cli.withCharset(StandardCharsets.UTF_8);
cli.withRedirectErrorStream(true);
return cli;
}
@Override
public @NotNull File getExecutableFile() {
return executableFile;
}
}
}

61
modules/debugger/src/main/java/com/falsepattern/zigbrains/zig/debugger/test/ZigDebugRunnerTest.java Normal file
View file

@ -0,0 +1,61 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.zig.debugger.test;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.falsepattern.zigbrains.project.execution.test.ProfileStateTest;
import com.falsepattern.zigbrains.project.execution.test.ZigExecConfigTest;
import com.falsepattern.zigbrains.project.toolchain.AbstractZigToolchain;
import com.falsepattern.zigbrains.project.toolchain.LocalZigToolchain;
import com.falsepattern.zigbrains.zig.debugger.base.ZigDebugParametersBase;
import com.falsepattern.zigbrains.zig.debugger.base.ZigDebugRunnerBase;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.notification.Notification;
import com.intellij.notification.NotificationType;
import com.intellij.notification.Notifications;
import com.jetbrains.cidr.execution.debugger.backend.DebuggerDriverConfiguration;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class ZigDebugRunnerTest extends ZigDebugRunnerBase<ProfileStateTest> {
@Override
public @NotNull @NonNls String getRunnerId() {
return "ZigDebugRunnerTest";
}
@Override
public boolean canRun(@NotNull String executorId, @NotNull RunProfile profile) {
return this.executorId.equals(executorId) &&
(profile instanceof ZigExecConfigTest);
}
@Override
protected @Nullable ZigDebugParametersBase<ProfileStateTest> getDebugParameters(ProfileStateTest profileStateTest, ExecutionEnvironment environment, DebuggerDriverConfiguration debuggerDriver, AbstractZigToolchain toolchain$) {
if (!(toolchain$ instanceof LocalZigToolchain toolchain)) {
Notifications.Bus.notify(new Notification("ZigBrains.Debugger.Error", "The debugger only supports local zig toolchains!", NotificationType.ERROR));
return null;
}
return new ZigDebugParametersTest(debuggerDriver, toolchain, profileStateTest);
}
@Override
protected @Nullable ProfileStateTest castProfileState(ProfileStateBase<?> state) {
return state instanceof ProfileStateTest state$ ? state$ : null;
}
}

6
modules/debugger/src/main/resources/META-INF/zigbrains-zig-debugger.xml
View file

@ -19,8 +19,10 @@
<resource-bundle>zigbrains.zig.debugger.Bundle</resource-bundle>
<extensions defaultExtensionNs="com.intellij">
<programRunner implementation="com.falsepattern.zigbrains.zig.debugger.ZigDebugRunner"
id="ZigDebugRunner"/>
<programRunner implementation="com.falsepattern.zigbrains.zig.debugger.run.ZigDebugRunnerRun"
id="ZigDebugRunnerRun"/>
<programRunner implementation="com.falsepattern.zigbrains.zig.debugger.test.ZigDebugRunnerTest"
id="ZigDebugRunnerTest"/>
<notificationGroup displayType="BALLOON"
bundle="zigbrains.zig.debugger.Bundle"

24
modules/lsp/src/main/java/com/falsepattern/zigbrains/lsp/contributors/LSPCompletionContributor.java
View file

@ -23,11 +23,8 @@ import com.intellij.codeInsight.completion.CompletionParameters;
import com.intellij.codeInsight.completion.CompletionProvider;
import com.intellij.codeInsight.completion.CompletionResultSet;
import com.intellij.codeInsight.completion.PlainPrefixMatcher;
import com.intellij.openapi.application.ex.ApplicationUtil;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.progress.ProcessCanceledException;
import com.intellij.openapi.progress.ProgressIndicatorProvider;
import com.intellij.util.ProcessingContext;
import org.eclipse.lsp4j.Position;
import org.jetbrains.annotations.NotNull;
@ -40,23 +37,18 @@ class LSPCompletionContributor extends CompletionContributor {
@Override
public void fillCompletionVariants(@NotNull CompletionParameters parameters, @NotNull CompletionResultSet result) {
CompletionProvider<CompletionParameters> provider = new CompletionProvider<CompletionParameters>() {
CompletionProvider<CompletionParameters> provider = new CompletionProvider<>() {
@Override
protected void addCompletions(@NotNull CompletionParameters parameters, @NotNull ProcessingContext context, @NotNull CompletionResultSet result) {
try {
ApplicationUtil.runWithCheckCanceled(() -> {
Editor editor = parameters.getEditor();
int offset = parameters.getOffset();
Position serverPos = DocumentUtils.offsetToLSPPos(editor, offset);
Editor editor = parameters.getEditor();
int offset = parameters.getOffset();
Position serverPos = DocumentUtils.offsetToLSPPos(editor, offset);
EditorEventManager manager = EditorEventManagerBase.forEditor(editor);
if (manager != null) {
result.addAllElements(manager.completion(serverPos));
}
return null;
}, ProgressIndicatorProvider.getGlobalProgressIndicator());
} catch (ProcessCanceledException ignored) {
// ProcessCanceledException can be ignored.
EditorEventManager manager = EditorEventManagerBase.forEditor(editor);
if (manager != null) {
result.addAllElements(manager.completion(serverPos));
}
} catch (Exception e) {
LOG.warn("LSP Completions ended with an error", e);
}

38
modules/lsp/src/main/java/com/falsepattern/zigbrains/lsp/editor/EditorEventManager.java
View file

@ -1302,13 +1302,7 @@ public class EditorEventManager {
val sourceOffset = element.getTextOffset();
val loc = requestDefinition(DocumentUtils.offsetToLSPPos(editor, sourceOffset));
invokeLater(() -> {
if (editor.isDisposed()) {
return;
}
gotoLocation(loc);
});
gotoLocation(loc);
}
// Tries to go to declaration / show usages based on the element which is
@ -1328,25 +1322,19 @@ public class EditorEventManager {
return;
}
invokeLater(() -> {
if (editor.isDisposed()) {
return;
}
String locUri = FileUtils.sanitizeURI(loc.getUri());
String locUri = FileUtils.sanitizeURI(loc.getUri());
if (identifier.getUri().equals(locUri)
&& sourceOffset >= DocumentUtils.LSPPosToOffset(editor, loc.getRange().getStart())
&& sourceOffset <= DocumentUtils.LSPPosToOffset(editor, loc.getRange().getEnd())) {
LSPReferencesAction referencesAction = (LSPReferencesAction) ActionManager.getInstance()
.getAction("LSPFindUsages");
if (referencesAction != null) {
referencesAction.forManagerAndOffset(this, sourceOffset);
}
} else {
gotoLocation(loc);
if (identifier.getUri().equals(locUri)
&& sourceOffset >= DocumentUtils.LSPPosToOffset(editor, loc.getRange().getStart())
&& sourceOffset <= DocumentUtils.LSPPosToOffset(editor, loc.getRange().getEnd())) {
LSPReferencesAction referencesAction = (LSPReferencesAction) ActionManager.getInstance()
.getAction("LSPFindUsages");
if (referencesAction != null) {
referencesAction.forManagerAndOffset(this, sourceOffset);
}
});
} else {
gotoLocation(loc);
}
}
public void gotoLocation(Location loc) {
@ -1359,7 +1347,7 @@ public class EditorEventManager {
if (file != null) {
OpenFileDescriptor descriptor = new OpenFileDescriptor(project, file);
VirtualFile finalFile = file;
writeAction(() -> {
invokeLater(() -> {
FileEditorManager.getInstance(project).openTextEditor(descriptor, true);
Editor srcEditor = FileUtils.editorFromVirtualFile(finalFile, project);
if (srcEditor != null) {

1
modules/project/.gitignore vendored Normal file
View file

@ -0,0 +1 @@
!src/**/build/

31
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/actions/AbstractZigRunExecutionConfigurationProducer.java
View file

@ -1,31 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.actions;
import com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfiguration;
import com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfigurationType;
import com.intellij.execution.actions.LazyRunConfigurationProducer;
import com.intellij.execution.configurations.ConfigurationFactory;
import org.jetbrains.annotations.NotNull;
public abstract class AbstractZigRunExecutionConfigurationProducer extends LazyRunConfigurationProducer<ZigRunExecutionConfiguration> {
@NotNull
@Override
public ConfigurationFactory getConfigurationFactory() {
return ZigRunExecutionConfigurationType.getInstance().getFactory();
}
}

67
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/actions/ZigRunExecutionConfigurationProducer.java → modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/base/ConfigProducerBase.java
View file

@ -14,34 +14,26 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.actions;
package com.falsepattern.zigbrains.project.execution.base;
import com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfiguration;
import com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfigurationType;
import com.falsepattern.zigbrains.project.execution.base.ZigExecConfigBase;
import com.falsepattern.zigbrains.zig.parser.ZigFile;
import com.falsepattern.zigbrains.zig.psi.ZigTypes;
import com.falsepattern.zigbrains.zig.util.PsiUtil;
import com.intellij.execution.actions.ConfigurationContext;
import com.intellij.execution.actions.ConfigurationFromContext;
import com.intellij.execution.actions.LazyRunConfigurationProducer;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.ConfigurationTypeUtil;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiElement;
import lombok.val;
import org.jetbrains.annotations.NotNull;
import java.util.Objects;
public class ZigRunExecutionConfigurationProducer extends AbstractZigRunExecutionConfigurationProducer{
public abstract class ConfigProducerBase<T extends ZigExecConfigBase<T>> extends LazyRunConfigurationProducer<T> {
@NotNull
@Override
public @NotNull ConfigurationFactory getConfigurationFactory() {
return Objects.requireNonNull(
ConfigurationTypeUtil.findConfigurationType(ZigRunExecutionConfigurationType.IDENTIFIER))
.getConfigurationFactories()[0];
}
public abstract ConfigurationFactory getConfigurationFactory();
@Override
protected boolean setupConfigurationFromContext(@NotNull ZigRunExecutionConfiguration configuration, @NotNull ConfigurationContext context, @NotNull Ref<PsiElement> sourceElement) {
protected final boolean setupConfigurationFromContext(@NotNull T configuration, @NotNull ConfigurationContext context, @NotNull Ref<PsiElement> sourceElement) {
var loc = context.getLocation();
if (loc == null) {
return false;
@ -56,21 +48,11 @@ public class ZigRunExecutionConfigurationProducer extends AbstractZigRunExecutio
}
var theFile = psiFile.getVirtualFile();
var filePath = theFile.getPath();
if (PsiUtil.getElementType(element) == ZigTypes.KEYWORD_TEST) {
configuration.command = "test " + filePath;
configuration.setName("Test " + theFile.getPresentableName());
} else if ("build.zig".equals(theFile.getName())) {
configuration.command = "build";
configuration.setName("Build");
} else {
configuration.command = "run " + filePath;
configuration.setName(theFile.getPresentableName());
}
return true;
return setupConfigurationFromContext(configuration, element, filePath, theFile);
}
@Override
public boolean isConfigurationFromContext(@NotNull ZigRunExecutionConfiguration configuration, @NotNull ConfigurationContext context) {
public final boolean isConfigurationFromContext(@NotNull T configuration, @NotNull ConfigurationContext context) {
if (context.getLocation() == null) {
return false;
}
@ -84,14 +66,35 @@ public class ZigRunExecutionConfigurationProducer extends AbstractZigRunExecutio
}
val vFile = file.getVirtualFile();
val filePath = vFile.getPath();
return isConfigurationFromContext(configuration, filePath, vFile, element);
}
/*
TODO implement these
@Override
protected boolean setupConfigurationFromContext(@NotNull ZigExecConfigRun configuration, PsiElement element, String filePath, VirtualFile theFile) {
if (PsiUtil.getElementType(element) == ZigTypes.KEYWORD_TEST) {
configuration.command = "test " + filePath;
configuration.setName("Test " + theFile.getPresentableName());
} else if ("build.zig".equals(theFile.getName())) {
configuration.command = "build";
configuration.setName("Build");
} else {
configuration.extraArgs = filePath;
configuration.setName(theFile.getPresentableName());
}
return true;
}
@Override
protected boolean isConfigurationFromContext(@NotNull ZigExecConfigRun configuration, String filePath, VirtualFile vFile, PsiElement element) {
if (!configuration.command.contains(filePath)) {
return configuration.command.startsWith("build") && vFile.getName().equals("build.zig");
}
return (PsiUtil.getElementType(element) == ZigTypes.KEYWORD_TEST) == configuration.command.startsWith("test ");
}
*/
@Override
public boolean shouldReplace(@NotNull ConfigurationFromContext self, @NotNull ConfigurationFromContext other) {
return self.getConfigurationType() instanceof ZigRunExecutionConfigurationType;
}
protected abstract boolean setupConfigurationFromContext(@NotNull T configuration, PsiElement element, String filePath, VirtualFile theFile);
protected abstract boolean isConfigurationFromContext(@NotNull T configuration, String filePath, VirtualFile vFile, PsiElement element);
}

17
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/configurations/ZigRunExecutionConfigurationRunProfileState.java → modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/base/ProfileStateBase.java
View file

@ -14,7 +14,7 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.configurations;
package com.falsepattern.zigbrains.project.execution.base;
import com.falsepattern.zigbrains.project.execution.ZigCapturingProcessHandler;
import com.falsepattern.zigbrains.project.runconfig.ZigProcessHandler;
@ -32,10 +32,10 @@ import org.jetbrains.annotations.NotNull;
import java.nio.charset.StandardCharsets;
public final class ZigRunExecutionConfigurationRunProfileState extends CommandLineState {
private final ZigRunExecutionConfiguration configuration;
public abstract class ProfileStateBase<T extends ZigExecConfigBase<T>> extends CommandLineState {
protected final T configuration;
public ZigRunExecutionConfigurationRunProfileState(ExecutionEnvironment environment, ZigRunExecutionConfiguration configuration) {
public ProfileStateBase(ExecutionEnvironment environment, T configuration) {
super(environment);
this.configuration = configuration;
}
@ -53,15 +53,15 @@ public final class ZigRunExecutionConfigurationRunProfileState extends CommandLi
.withWorkDirectory(workingDirectory.toString())
.withCharset(StandardCharsets.UTF_8)
.withRedirectErrorStream(true)
.withParameters(configuration.command.split(" "));
.withParameters(configuration.buildCommandLineArgs());
}
public ZigRunExecutionConfiguration configuration() {
public T configuration() {
return configuration;
}
public DefaultExecutionResult executeCommandLine(GeneralCommandLine commandLine,
ExecutionEnvironment environment) throws ExecutionException {
public DefaultExecutionResult executeCommandLine(GeneralCommandLine commandLine, ExecutionEnvironment environment)
throws ExecutionException {
val handler = startProcess(commandLine);
val console = getConsoleBuilder().getConsole();
console.attachToProcess(handler);
@ -73,5 +73,4 @@ public final class ZigRunExecutionConfigurationRunProfileState extends CommandLi
ProcessTerminatedListener.attach(handler);
return handler;
}
}

92
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/base/ZigConfigEditor.java Normal file
View file

@ -0,0 +1,92 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.base;
import com.falsepattern.zigbrains.project.ui.WorkingDirectoryComponent;
import com.falsepattern.zigbrains.project.ui.ZigFilePathPanel;
import com.intellij.openapi.options.ConfigurationException;
import com.intellij.openapi.options.SettingsEditor;
import com.intellij.openapi.ui.LabeledComponent;
import com.intellij.openapi.ui.TextFieldWithBrowseButton;
import com.intellij.ui.dsl.builder.AlignX;
import com.intellij.ui.dsl.builder.AlignY;
import com.intellij.ui.dsl.builder.Panel;
import org.jetbrains.annotations.NotNull;
import javax.swing.JComponent;
import java.nio.file.Paths;
import java.util.Objects;
import static com.intellij.ui.dsl.builder.BuilderKt.panel;
public class ZigConfigEditor<T extends ZigExecConfigBase<T>> extends SettingsEditor<T> {
protected final LabeledComponent<TextFieldWithBrowseButton> workingDirectoryComponent =
new WorkingDirectoryComponent();
@Override
protected void applyEditorTo(@NotNull T s) throws ConfigurationException {
s.workingDirectory = Paths.get(workingDirectoryComponent.getComponent().getText());
}
@Override
protected void resetEditorFrom(@NotNull T s) {
workingDirectoryComponent.getComponent().setText(Objects.requireNonNullElse(s.workingDirectory, "").toString());
}
@Override
protected final @NotNull JComponent createEditor() {
return panel((p) -> {
constructPanel(p);
return null;
});
}
protected void constructPanel(Panel p) {
p.row(workingDirectoryComponent.getLabel(), (r) -> {
r.cell(workingDirectoryComponent).resizableColumn().align(AlignX.FILL).align(AlignY.FILL);
return null;
});
}
public static abstract class WithFilePath<T extends ZigExecConfigBase<T>> extends ZigConfigEditor<T> {
private final ZigFilePathPanel filePathPanel = new ZigFilePathPanel();
@Override
protected void applyEditorTo(@NotNull T s) throws ConfigurationException {
super.applyEditorTo(s);
setFilePath(s, filePathPanel.getText());
}
@Override
protected void resetEditorFrom(@NotNull T s) {
super.resetEditorFrom(s);
filePathPanel.setText(Objects.requireNonNullElse(getFilePath(s), ""));
}
@Override
protected void constructPanel(Panel p) {
super.constructPanel(p);
p.row("Target file", (r) -> {
r.cell(filePathPanel).resizableColumn().align(AlignX.FILL).align(AlignY.FILL);
return null;
});
}
protected abstract String getFilePath(T config);
protected abstract void setFilePath(T config, String path);
}
}

21
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/configurations/AbstractZigExecutionConfiguration.java → modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/base/ZigExecConfigBase.java
View file

@ -14,44 +14,37 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.configurations;
package com.falsepattern.zigbrains.project.execution.base;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.LocatableConfigurationBase;
import com.intellij.execution.configurations.RunProfileState;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.NlsActions;
import com.intellij.openapi.util.text.Strings;
import lombok.val;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.nio.file.Path;
import java.util.Optional;
public abstract class AbstractZigExecutionConfiguration extends LocatableConfigurationBase<RunProfileState> {
public abstract class ZigExecConfigBase<T extends ZigExecConfigBase<T>> extends LocatableConfigurationBase<ProfileStateBase<T>> {
public @Nullable Path workingDirectory;
public AbstractZigExecutionConfiguration(@NotNull Project project, @NotNull ConfigurationFactory factory, @Nullable String name) {
public ZigExecConfigBase(@NotNull Project project, @NotNull ConfigurationFactory factory, @Nullable String name) {
super(project, factory, name);
workingDirectory = project.isDefault() ? null : Optional.ofNullable(project.getBasePath())
.map(Path::of)
.orElse(null);
}
public abstract String getCommand();
public abstract void setCommand(String value);
public abstract String[] buildCommandLineArgs();
@Override
public @Nullable @NlsActions.ActionText String suggestedName() {
val cmd = getCommand();
var spaceIndex = cmd.indexOf(' ');
return Strings.capitalize(spaceIndex > 0 ? cmd.substring(0, spaceIndex) : cmd);
}
public abstract @Nullable @NlsActions.ActionText String suggestedName();
@Override
public abstract @Nullable RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment environment)
public abstract @Nullable ProfileStateBase<T> getState(@NotNull Executor executor, @NotNull ExecutionEnvironment environment)
throws ExecutionException;
}

18
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/linemarker/ZigTopLevelDeclarationLineMarkerContributorBase.java → modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/base/ZigTopLevelLineMarkerBase.java
View file

@ -14,7 +14,7 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.linemarker;
package com.falsepattern.zigbrains.project.execution.base;
import com.falsepattern.zigbrains.zig.psi.ZigTypes;
import com.falsepattern.zigbrains.zig.util.PsiUtil;
@ -28,9 +28,8 @@ import org.jetbrains.annotations.Nullable;
import javax.swing.Icon;
public abstract class ZigTopLevelDeclarationLineMarkerContributorBase extends RunLineMarkerContributor {
@Override
public @Nullable Info getInfo(@NotNull PsiElement element) {
public abstract class ZigTopLevelLineMarkerBase extends RunLineMarkerContributor {
private @Nullable PsiElement getParentIfTopLevel(@NotNull PsiElement element) {
PsiElement parent = getDeclaration(element);
int nestingLevel = 0;
@ -44,7 +43,18 @@ public abstract class ZigTopLevelDeclarationLineMarkerContributorBase extends Ru
if (nestingLevel != 1) {
return null;
}
return parent;
}
public boolean elementMatches(@NotNull PsiElement element) {
return getParentIfTopLevel(element) != null;
}
@Override
public @Nullable Info getInfo(@NotNull PsiElement element) {
val parent = getParentIfTopLevel(element);
if (parent == null)
return null;
val actions = ExecutorAction.getActions(0);
return new Info(getIcon(element), actions, null);
}

44
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/build/ConfigProducerBuild.java Normal file
View file

@ -0,0 +1,44 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.build;
import com.falsepattern.zigbrains.project.execution.base.ConfigProducerBase;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
public class ConfigProducerBuild extends ConfigProducerBase<ZigExecConfigBuild> {
@Override
public @NotNull ConfigurationFactory getConfigurationFactory() {
return ConfigTypeBuild.getInstance().getConfigurationFactories()[0];
}
@Override
protected boolean setupConfigurationFromContext(@NotNull ZigExecConfigBuild configuration, PsiElement element, String filePath, VirtualFile theFile) {
if (ZigLineMarkerBuild.UTILITY_INSTANCE.elementMatches(element)) {
configuration.setName("Build");
return true;
}
return false;
}
@Override
protected boolean isConfigurationFromContext(@NotNull ZigExecConfigBuild configuration, String filePath, VirtualFile vFile, PsiElement element) {
return true;
}
}

55
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/build/ConfigTypeBuild.java Normal file
View file

@ -0,0 +1,55 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.build;
import com.falsepattern.zigbrains.zig.Icons;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.ConfigurationTypeBase;
import com.intellij.execution.configurations.ConfigurationTypeUtil;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
public class ConfigTypeBuild extends ConfigurationTypeBase {
public static final String IDENTIFIER = "ZIGBRAINS_BUILD";
public static ConfigTypeBuild getInstance() {
return ConfigurationTypeUtil.findConfigurationType(ConfigTypeBuild.class);
}
public ConfigTypeBuild() {
super(IDENTIFIER, "ZigBuild", "Zig Build", Icons.ZIG);
addFactory(new ConfigFactoryBuild());
}
public class ConfigFactoryBuild extends ConfigurationFactory {
public ConfigFactoryBuild() {
super(ConfigTypeBuild.this);
}
@Override
public @NotNull RunConfiguration createTemplateConfiguration(@NotNull Project project) {
return new ZigExecConfigBuild(project, this);
}
@Override
public @NotNull @NonNls String getId() {
return IDENTIFIER;
}
}
}

26
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/build/ProfileStateBuild.java Normal file
View file

@ -0,0 +1,26 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.build;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.intellij.execution.runners.ExecutionEnvironment;
public class ProfileStateBuild extends ProfileStateBase<ZigExecConfigBuild> {
public ProfileStateBuild(ExecutionEnvironment environment, ZigExecConfigBuild configuration) {
super(environment, configuration);
}
}

112
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/build/ZigExecConfigBuild.java Normal file
View file

@ -0,0 +1,112 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.build;
import com.falsepattern.zigbrains.project.execution.base.ZigConfigEditor;
import com.falsepattern.zigbrains.project.execution.base.ZigExecConfigBase;
import com.falsepattern.zigbrains.project.util.ElementUtil;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.options.ConfigurationException;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.InvalidDataException;
import com.intellij.ui.components.JBTextField;
import com.intellij.ui.dsl.builder.AlignX;
import com.intellij.ui.dsl.builder.AlignY;
import com.intellij.ui.dsl.builder.Panel;
import lombok.val;
import org.apache.groovy.util.Arrays;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Objects;
public class ZigExecConfigBuild extends ZigExecConfigBase<ZigExecConfigBuild> {
public String extraArguments = "";
public ZigExecConfigBuild(@NotNull Project project, @NotNull ConfigurationFactory factory) {
super(project, factory, "Zig Build");
}
@Override
public String[] buildCommandLineArgs() {
val base = new String[]{"build"};
if (extraArguments.isBlank()) {
return base;
} else {
return Arrays.concat(base, extraArguments.split(" "));
}
}
@Override
public @Nullable String suggestedName() {
return "Build";
}
@Override
public @NotNull Editor getConfigurationEditor() {
return new Editor();
}
@Override
public @Nullable ProfileStateBuild getState(@NotNull Executor executor, @NotNull ExecutionEnvironment environment) {
return new ProfileStateBuild(environment, this);
}
@Override
public void readExternal(@NotNull Element element) throws InvalidDataException {
super.readExternal(element);
val extraArguments = ElementUtil.readString(element, "extraArguments");
if (extraArguments != null) {
this.extraArguments = extraArguments;
}
}
@Override
public void writeExternal(@NotNull Element element) {
super.writeExternal(element);
ElementUtil.writeString(element, "extraArguments", extraArguments);
}
public static class Editor extends ZigConfigEditor<ZigExecConfigBuild> {
private final JBTextField extraArgs = new JBTextField();
@Override
protected void applyEditorTo(@NotNull ZigExecConfigBuild s) throws ConfigurationException {
super.applyEditorTo(s);
s.extraArguments = extraArgs.getText();
}
@Override
protected void resetEditorFrom(@NotNull ZigExecConfigBuild s) {
super.resetEditorFrom(s);
extraArgs.setText(Objects.requireNonNullElse(s.extraArguments, ""));
}
@Override
protected void constructPanel(Panel p) {
super.constructPanel(p);
p.row("Extra arguments", (r) -> {
r.cell(extraArgs).resizableColumn().align(AlignX.FILL).align(AlignY.FILL);
return null;
});
}
}
}

6
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/linemarker/ZigBuildLineMarkerContributor.java → modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/build/ZigLineMarkerBuild.java
View file

@ -14,8 +14,9 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.linemarker;
package com.falsepattern.zigbrains.project.execution.build;
import com.falsepattern.zigbrains.project.execution.base.ZigTopLevelLineMarkerBase;
import com.falsepattern.zigbrains.zig.psi.ZigTypes;
import com.falsepattern.zigbrains.zig.util.PsiUtil;
import com.intellij.icons.AllIcons;
@ -25,7 +26,8 @@ import org.jetbrains.annotations.Nullable;
import javax.swing.Icon;
public class ZigBuildLineMarkerContributor extends ZigTopLevelDeclarationLineMarkerContributorBase {
public class ZigLineMarkerBuild extends ZigTopLevelLineMarkerBase {
public static final ZigLineMarkerBuild UTILITY_INSTANCE = new ZigLineMarkerBuild();
@Override
protected @Nullable PsiElement getDeclaration(@NotNull PsiElement element) {
if (PsiUtil.getElementType(element) != ZigTypes.IDENTIFIER) {

74
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/configurations/ZigRunExecutionConfiguration.java
View file

@ -1,74 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.configurations;
import com.falsepattern.zigbrains.project.execution.configurations.ui.ZigRunExecutionConfigurationEditor;
import com.falsepattern.zigbrains.project.util.ElementUtil;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.configurations.RunProfileState;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.options.SettingsEditor;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.InvalidDataException;
import lombok.Getter;
import lombok.Setter;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class ZigRunExecutionConfiguration extends AbstractZigExecutionConfiguration{
@Getter
@Setter
public String command = "run";
public ZigRunExecutionConfiguration(@NotNull Project project, @NotNull ConfigurationFactory factory, @Nullable String name) {
super(project, factory, name);
}
@Override
public @NotNull SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
return new ZigRunExecutionConfigurationEditor();
}
@Override
public @Nullable RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment environment)
throws ExecutionException {
return new ZigRunExecutionConfigurationRunProfileState(environment, this);
}
@Override
public void readExternal(@NotNull Element element) throws InvalidDataException {
super.readExternal(element);
var command = ElementUtil.readString(element, "command");
if (command != null) {
this.command = command;
}
}
@Override
public void writeExternal(@NotNull Element element) {
super.writeExternal(element);
ElementUtil.writeString(element, "command", command);
}
}

39
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/configurations/ZigRunExecutionConfigurationFactory.java
View file

@ -1,39 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.configurations;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
public class ZigRunExecutionConfigurationFactory extends ConfigurationFactory {
public ZigRunExecutionConfigurationFactory(ZigRunExecutionConfigurationType type) {
super(type);
}
@Override
public @NotNull RunConfiguration createTemplateConfiguration(@NotNull Project project) {
return new ZigRunExecutionConfiguration(project, this, "Zig Run");
}
@Override
public @NotNull @NonNls String getId() {
return "ZIG_RUN";
}
}

40
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/configurations/ZigRunExecutionConfigurationType.java
View file

@ -1,40 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.configurations;
import com.falsepattern.zigbrains.zig.Icons;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.ConfigurationTypeBase;
import com.intellij.execution.configurations.ConfigurationTypeUtil;
public class ZigRunExecutionConfigurationType extends ConfigurationTypeBase {
public static final String IDENTIFIER = "ZIG_RUN_CONFIGURATION";
public static ZigRunExecutionConfigurationType getInstance() {
return ConfigurationTypeUtil.findConfigurationType(ZigRunExecutionConfigurationType.class);
}
public ZigRunExecutionConfigurationType() {
super(IDENTIFIER, "ZigRun", "Zig Run", Icons.ZIG);
addFactory(new ZigRunExecutionConfigurationFactory(this));
}
public ConfigurationFactory getFactory() {
return getConfigurationFactories()[0];
}
}

49
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/configurations/ui/AbstractZigExecutionConfigurationEditor.java
View file

@ -1,49 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.configurations.ui;
import com.falsepattern.zigbrains.project.execution.configurations.AbstractZigExecutionConfiguration;
import com.falsepattern.zigbrains.project.ui.ZigCommandLinePanel;
import com.intellij.openapi.options.ConfigurationException;
import com.intellij.openapi.options.SettingsEditor;
import com.intellij.openapi.ui.LabeledComponent;
import com.intellij.openapi.ui.TextFieldWithBrowseButton;
import org.jetbrains.annotations.NotNull;
import java.nio.file.Paths;
public abstract class AbstractZigExecutionConfigurationEditor<T extends AbstractZigExecutionConfiguration> extends
SettingsEditor<T> {
public abstract ZigCommandLinePanel getCommandLinePanel();
protected final LabeledComponent<TextFieldWithBrowseButton> workingDirectoryComponent = new WorkingDirectoryComponent();
@Override
protected void applyEditorTo(@NotNull T s) throws ConfigurationException {
s.setCommand(getCommandLinePanel().getText());
s.workingDirectory = Paths.get(workingDirectoryComponent.getComponent().getText());
}
@Override
protected void resetEditorFrom(@NotNull T s) {
getCommandLinePanel().setText(s.getCommand());
if (s.workingDirectory == null) {
workingDirectoryComponent.getComponent().setText("");
} else {
workingDirectoryComponent.getComponent().setText(s.workingDirectory.toString());
}
}
}

56
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/configurations/ui/ZigRunExecutionConfigurationEditor.java
View file

@ -1,56 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.configurations.ui;
import com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfiguration;
import com.falsepattern.zigbrains.project.ui.ZigCommandLinePanel;
import com.intellij.ui.dsl.builder.AlignX;
import com.intellij.ui.dsl.builder.AlignY;
import lombok.Getter;
import org.jetbrains.annotations.NotNull;
import javax.swing.JComponent;
import javax.swing.JPanel;
import static com.intellij.ui.dsl.builder.BuilderKt.panel;
public class ZigRunExecutionConfigurationEditor extends AbstractZigExecutionConfigurationEditor<ZigRunExecutionConfiguration> {
private JPanel panel = null;
@Getter
private final ZigCommandLinePanel commandLinePanel = new ZigCommandLinePanel();
@Override
protected @NotNull JComponent createEditor() {
return panel = panel((p) -> {
p.row("Run Config Command", (r) -> {
r.cell(commandLinePanel)
.resizableColumn()
.align(AlignX.FILL)
.align(AlignY.FILL);
return null;
});
p.row(workingDirectoryComponent.getLabel(), (r) -> {
r.cell(workingDirectoryComponent)
.resizableColumn()
.align(AlignX.FILL)
.align(AlignY.FILL);
return null;
});
return null;
});
}
}

42
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/linemarker/ZigAggregateLineMarkerContributor.java
View file

@ -1,42 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.linemarker;
import com.intellij.execution.lineMarker.RunLineMarkerContributor;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class ZigAggregateLineMarkerContributor extends RunLineMarkerContributor {
private final List<RunLineMarkerContributor> contributors = List.of(
new ZigExecutableRunLineMarkerContributor(),
new ZigTestLineMarkerContributor(),
new ZigBuildLineMarkerContributor()
);
@Override
public @Nullable Info getInfo(@NotNull PsiElement element) {
for (var contributor: contributors) {
var info = contributor.getInfo(element);
if (info != null) {
return info;
}
}
return null;
}
}

51
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/run/ConfigProducerRun.java Normal file
View file

@ -0,0 +1,51 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.run;
import com.falsepattern.zigbrains.project.execution.base.ConfigProducerBase;
import com.intellij.execution.actions.ConfigurationFromContext;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
public class ConfigProducerRun extends ConfigProducerBase<ZigExecConfigRun> {
@Override
public @NotNull ConfigurationFactory getConfigurationFactory() {
return ConfigTypeRun.getInstance().getConfigurationFactories()[0];
}
@Override
protected boolean setupConfigurationFromContext(@NotNull ZigExecConfigRun configuration, PsiElement element, String filePath, VirtualFile theFile) {
if (ZigLineMarkerRun.UTILITY_INSTANCE.elementMatches(element)) {
configuration.filePath = filePath;
configuration.setName(theFile.getPresentableName());
return true;
}
return false;
}
@Override
protected boolean isConfigurationFromContext(@NotNull ZigExecConfigRun configuration, String filePath, VirtualFile vFile, PsiElement element) {
return configuration.filePath.equals(filePath);
}
@Override
public boolean shouldReplace(@NotNull ConfigurationFromContext self, @NotNull ConfigurationFromContext other) {
return self.getConfigurationType() instanceof ConfigTypeRun;
}
}

55
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/run/ConfigTypeRun.java Normal file
View file

@ -0,0 +1,55 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.run;
import com.falsepattern.zigbrains.zig.Icons;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.ConfigurationTypeBase;
import com.intellij.execution.configurations.ConfigurationTypeUtil;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
public class ConfigTypeRun extends ConfigurationTypeBase {
public static final String IDENTIFIER = "ZIGBRAINS_RUN";
public static ConfigTypeRun getInstance() {
return ConfigurationTypeUtil.findConfigurationType(ConfigTypeRun.class);
}
public ConfigTypeRun() {
super(IDENTIFIER, "ZigRun", "Zig Run", Icons.ZIG);
addFactory(new ConfigFactoryRun());
}
public class ConfigFactoryRun extends ConfigurationFactory {
public ConfigFactoryRun() {
super(ConfigTypeRun.this);
}
@Override
public @NotNull RunConfiguration createTemplateConfiguration(@NotNull Project project) {
return new ZigExecConfigRun(project, this);
}
@Override
public @NotNull @NonNls String getId() {
return IDENTIFIER;
}
}
}

26
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/run/ProfileStateRun.java Normal file
View file

@ -0,0 +1,26 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.run;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.intellij.execution.runners.ExecutionEnvironment;
public final class ProfileStateRun extends ProfileStateBase<ZigExecConfigRun> {
public ProfileStateRun(ExecutionEnvironment environment, ZigExecConfigRun configuration) {
super(environment, configuration);
}
}

90
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/run/ZigExecConfigRun.java Normal file
View file

@ -0,0 +1,90 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.run;
import com.falsepattern.zigbrains.project.execution.base.ZigExecConfigBase;
import com.falsepattern.zigbrains.project.execution.base.ZigConfigEditor;
import com.falsepattern.zigbrains.project.util.ElementUtil;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.InvalidDataException;
import lombok.Getter;
import lombok.Setter;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@Setter
@Getter
public class ZigExecConfigRun extends ZigExecConfigBase<ZigExecConfigRun> {
public String filePath = "";
public ZigExecConfigRun(@NotNull Project project, @NotNull ConfigurationFactory factory) {
super(project, factory, "Zig Run");
}
@Override
public String[] buildCommandLineArgs() {
return new String[]{"run", filePath};
}
@Override
public @Nullable String suggestedName() {
return "Run";
}
@Override
public @NotNull Editor getConfigurationEditor() {
return new Editor();
}
@Override
public @Nullable ProfileStateRun getState(@NotNull Executor executor, @NotNull ExecutionEnvironment environment) {
return new ProfileStateRun(environment, this);
}
@Override
public void readExternal(@NotNull Element element) throws InvalidDataException {
super.readExternal(element);
var filePath = ElementUtil.readString(element, "filePath");
if (filePath != null) {
this.filePath = filePath;
}
}
@Override
public void writeExternal(@NotNull Element element) {
super.writeExternal(element);
ElementUtil.writeString(element, "filePath", filePath);
}
public static class Editor extends ZigConfigEditor.WithFilePath<ZigExecConfigRun> {
@Override
protected String getFilePath(ZigExecConfigRun config) {
return config.filePath;
}
@Override
protected void setFilePath(ZigExecConfigRun config, String path) {
config.filePath = path;
}
}
}

6
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/linemarker/ZigExecutableRunLineMarkerContributor.java → modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/run/ZigLineMarkerRun.java
View file

@ -14,8 +14,9 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.linemarker;
package com.falsepattern.zigbrains.project.execution.run;
import com.falsepattern.zigbrains.project.execution.base.ZigTopLevelLineMarkerBase;
import com.falsepattern.zigbrains.zig.psi.ZigTypes;
import com.falsepattern.zigbrains.zig.util.PsiUtil;
import com.intellij.icons.AllIcons;
@ -25,7 +26,8 @@ import org.jetbrains.annotations.Nullable;
import javax.swing.Icon;
public class ZigExecutableRunLineMarkerContributor extends ZigTopLevelDeclarationLineMarkerContributorBase {
public class ZigLineMarkerRun extends ZigTopLevelLineMarkerBase {
public static final ZigLineMarkerRun UTILITY_INSTANCE = new ZigLineMarkerRun();
@Override
protected @Nullable PsiElement getDeclaration(@NotNull PsiElement element) {
if (PsiUtil.getElementType(element) != ZigTypes.IDENTIFIER) {

52
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/test/ConfigProducerTest.java Normal file
View file

@ -0,0 +1,52 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.test;
import com.falsepattern.zigbrains.project.execution.base.ConfigProducerBase;
import com.falsepattern.zigbrains.project.execution.run.ConfigTypeRun;
import com.intellij.execution.actions.ConfigurationFromContext;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
public class ConfigProducerTest extends ConfigProducerBase<ZigExecConfigTest> {
@Override
public @NotNull ConfigurationFactory getConfigurationFactory() {
return ConfigTypeTest.getInstance().getConfigurationFactories()[0];
}
@Override
protected boolean setupConfigurationFromContext(@NotNull ZigExecConfigTest configuration, PsiElement element, String filePath, VirtualFile theFile) {
if (ZigLineMarkerTest.UTILITY_INSTANCE.elementMatches(element)) {
configuration.filePath = filePath;
configuration.setName("all tests in " + theFile.getPresentableName());
return true;
}
return false;
}
@Override
protected boolean isConfigurationFromContext(@NotNull ZigExecConfigTest configuration, String filePath, VirtualFile vFile, PsiElement element) {
return configuration.filePath.equals(filePath);
}
@Override
public boolean shouldReplace(@NotNull ConfigurationFromContext self, @NotNull ConfigurationFromContext other) {
return self.getConfigurationType() instanceof ConfigTypeRun;
}
}

54
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/test/ConfigTypeTest.java Normal file
View file

@ -0,0 +1,54 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.test;
import com.falsepattern.zigbrains.zig.Icons;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.ConfigurationTypeBase;
import com.intellij.execution.configurations.ConfigurationTypeUtil;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
public class ConfigTypeTest extends ConfigurationTypeBase {
public static final String IDENTIFIER = "ZIGBRAINS_TEST";
public static ConfigTypeTest getInstance() {
return ConfigurationTypeUtil.findConfigurationType(ConfigTypeTest.class);
}
public ConfigTypeTest() {
super(IDENTIFIER, "ZigTest", "Zig Test", Icons.ZIG);
addFactory(new ConfigFactoryTest());
}
public class ConfigFactoryTest extends ConfigurationFactory {
public ConfigFactoryTest() {
super(ConfigTypeTest.this);
}
@Override
public @NotNull RunConfiguration createTemplateConfiguration(@NotNull Project project) {
return new ZigExecConfigTest(project, this);
}
@Override
public @NotNull @NonNls String getId() {
return IDENTIFIER;
}
}
}

26
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/test/ProfileStateTest.java Normal file
View file

@ -0,0 +1,26 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.test;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.intellij.execution.runners.ExecutionEnvironment;
public class ProfileStateTest extends ProfileStateBase<ZigExecConfigTest> {
public ProfileStateTest(ExecutionEnvironment environment, ZigExecConfigTest configuration) {
super(environment, configuration);
}
}

69
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/test/ZigExecConfigTest.java Normal file
View file

@ -0,0 +1,69 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.test;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.falsepattern.zigbrains.project.execution.base.ZigExecConfigBase;
import com.falsepattern.zigbrains.project.execution.base.ZigConfigEditor;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.options.SettingsEditor;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class ZigExecConfigTest extends ZigExecConfigBase<ZigExecConfigTest> {
public String filePath = "";
public ZigExecConfigTest(@NotNull Project project, @NotNull ConfigurationFactory factory) {
super(project, factory, "Zig Test");
}
@Override
public String[] buildCommandLineArgs() {
return new String[]{"test", filePath};
}
@Override
public @Nullable String suggestedName() {
return "Test";
}
@Override
public @Nullable ProfileStateBase<ZigExecConfigTest> getState(@NotNull Executor executor, @NotNull ExecutionEnvironment environment) {
return new ProfileStateTest(environment, this);
}
@Override
public @NotNull SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
return new Editor();
}
public static class Editor extends ZigConfigEditor.WithFilePath<ZigExecConfigTest> {
@Override
protected String getFilePath(ZigExecConfigTest config) {
return config.filePath;
}
@Override
protected void setFilePath(ZigExecConfigTest config, String path) {
config.filePath = path;
}
}
}

8
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/linemarker/ZigTestLineMarkerContributor.java → modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/test/ZigLineMarkerTest.java
View file

@ -14,8 +14,9 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.linemarker;
package com.falsepattern.zigbrains.project.execution.test;
import com.falsepattern.zigbrains.project.execution.base.ZigTopLevelLineMarkerBase;
import com.falsepattern.zigbrains.zig.psi.ZigTypes;
import com.falsepattern.zigbrains.zig.util.PsiUtil;
import com.intellij.icons.AllIcons;
@ -25,7 +26,8 @@ import org.jetbrains.annotations.Nullable;
import javax.swing.Icon;
public class ZigTestLineMarkerContributor extends ZigTopLevelDeclarationLineMarkerContributorBase {
public class ZigLineMarkerTest extends ZigTopLevelLineMarkerBase {
public static final ZigLineMarkerTest UTILITY_INSTANCE = new ZigLineMarkerTest();
@Override
protected @Nullable PsiElement getDeclaration(@NotNull PsiElement element) {
if (PsiUtil.getElementType(element) != ZigTypes.KEYWORD_TEST) {
@ -40,6 +42,6 @@ public class ZigTestLineMarkerContributor extends ZigTopLevelDeclarationLineMark
@Override
protected @NotNull Icon getIcon(@NotNull PsiElement element) {
return AllIcons.RunConfigurations.TestState.Run;
return AllIcons.RunConfigurations.TestState.Run_run;
}
}

3
modules/project/src/main/java/com/falsepattern/zigbrains/project/ide/newproject/ZigNewProjectPanel.java
View file

@ -49,7 +49,8 @@ public class ZigNewProjectPanel implements Disposable {
private final List<ZigProjectTemplate> defaultTemplates = Arrays.asList(
ZigDefaultTemplate.ZigExecutableTemplate.INSTANCE,
ZigDefaultTemplate.ZigLibraryTemplate.INSTANCE
ZigDefaultTemplate.ZigLibraryTemplate.INSTANCE,
ZigDefaultTemplate.ZigInitTemplate.INSTANCE
);
private final DefaultListModel<ZigProjectTemplate> templateListModel = JBList.createDefaultListModel(defaultTemplates);

16
modules/project/src/main/java/com/falsepattern/zigbrains/project/ide/project/ZigDefaultTemplate.java
View file

@ -34,7 +34,7 @@ public sealed abstract class ZigDefaultTemplate extends ZigProjectTemplate {
@Override
public Map<String, String> fileTemplates() {
return Map.of("main.zig", "application",
return Map.of("src/main.zig", "application",
"build.zig", "application",
"build.zig.zon", "shared");
}
@ -48,9 +48,21 @@ public sealed abstract class ZigDefaultTemplate extends ZigProjectTemplate {
@Override
public Map<String, String> fileTemplates() {
return Map.of("root.zig", "static",
return Map.of("src/root.zig", "static",
"build.zig", "static",
"build.zig.zon", "shared");
}
}
public static final class ZigInitTemplate extends ZigDefaultTemplate {
public static final ZigInitTemplate INSTANCE = new ZigInitTemplate();
private ZigInitTemplate() {
super("Generate using \"zig init\"", true);
}
@Override
public Map<String, String> fileTemplates() {
throw new UnsupportedOperationException();
}
}
}

67
modules/project/src/main/java/com/falsepattern/zigbrains/project/platform/ZigDirectoryProjectGenerator.java
View file

@ -17,12 +17,17 @@
package com.falsepattern.zigbrains.project.platform;
import com.falsepattern.zigbrains.project.ide.newproject.ZigProjectConfigurationData;
import com.falsepattern.zigbrains.project.ide.project.ZigDefaultTemplate;
import com.falsepattern.zigbrains.project.ide.util.projectwizard.ZigProjectSettingsStep;
import com.falsepattern.zigbrains.project.openapi.components.ZigProjectSettingsService;
import com.falsepattern.zigbrains.zig.Icons;
import com.intellij.facet.ui.ValidationResult;
import com.intellij.ide.util.projectWizard.AbstractNewProjectStep;
import com.intellij.ide.util.projectWizard.CustomStepProjectGenerator;
import com.intellij.notification.Notification;
import com.intellij.notification.NotificationType;
import com.intellij.notification.Notifications;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.WriteAction;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
@ -76,24 +81,56 @@ public class ZigDirectoryProjectGenerator implements DirectoryProjectGenerator<Z
val settings = data.settings();
var svc = ZigProjectSettingsService.getInstance(project);
svc.getState().setToolchain(settings.toolchain());
val toolchain = settings.toolchain();
svc.getState().setToolchain(toolchain);
val template = data.selectedTemplate();
try {
WriteAction.run(() -> {
val srcDir = baseDir.createChildDirectory(this, "src");
for (val fileTemplate : template.fileTemplates().entrySet()) {
val fileName = fileTemplate.getKey();
val templateDir = fileTemplate.getValue();
val resourceData = getResourceString("project-gen/" + templateDir + "/" + fileName + ".template");
val targetFile = srcDir.createChildData(this, fileName);
VfsUtil.saveText(targetFile, resourceData);
}
});
} catch (IOException e) {
throw new RuntimeException(e);
if (template instanceof ZigDefaultTemplate.ZigInitTemplate) {
if (toolchain == null) {
Notifications.Bus.notify(new Notification("ZigBrains.Project",
"Tried to generate project with zig init, but zig toolchain is invalid!",
NotificationType.ERROR));
return;
}
val zig = toolchain.zig();
val resultOpt = zig.callWithArgs(baseDir.toNioPath(), 10000, "init");
if (resultOpt.isEmpty()) {
Notifications.Bus.notify(new Notification("ZigBrains.Project",
"Failed to invoke \"zig init\"!",
NotificationType.ERROR));
return;
}
val result = resultOpt.get();
if (result.getExitCode() != 0) {
Notifications.Bus.notify(new Notification("ZigBrains.Project",
"\"zig init\" failed with exit code " + result.getExitCode() + "! Check the IDE log files!",
NotificationType.ERROR));
System.err.println(result.getStderr());
}
} else {
try {
val projectName = project.getName();
WriteAction.run(() -> {
for (val fileTemplate : template.fileTemplates().entrySet()) {
var fileName = fileTemplate.getKey();
VirtualFile parentDir;
if (fileName.contains("/")) {
val slashIndex = fileName.indexOf('/');
parentDir = baseDir.createChildDirectory(this, fileName.substring(0, slashIndex));
fileName = fileName.substring(slashIndex + 1);
} else {
parentDir = baseDir;
}
val templateDir = fileTemplate.getValue();
val resourceData = getResourceString("project-gen/" + templateDir + "/" + fileName + ".template").replace("@@PROJECT_NAME@@", projectName);
val targetFile = parentDir.createChildData(this, fileName);
VfsUtil.saveText(targetFile, resourceData);
}
});
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

48
modules/project/src/main/java/com/falsepattern/zigbrains/project/runconfig/ZigDefaultProgramRunnerBase.java
View file

@ -1,48 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.runconfig;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.configurations.RunProfileState;
import com.intellij.execution.configurations.RunnerSettings;
import com.intellij.execution.runners.DefaultProgramRunnerKt;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.execution.runners.GenericProgramRunner;
import com.intellij.execution.runners.ProgramRunner;
import com.intellij.execution.ui.RunContentDescriptor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public abstract class ZigDefaultProgramRunnerBase extends GenericProgramRunner<RunnerSettings> {
@Override
protected final void execute(@NotNull ExecutionEnvironment environment, @Nullable ProgramRunner.Callback callback, @NotNull RunProfileState state) {
super.execute(environment, callback, state);
}
@Override
protected void execute(@NotNull ExecutionEnvironment environment, @NotNull RunProfileState state) {
super.execute(environment, state);
}
@Nullable
@Override
protected RunContentDescriptor doExecute(@NotNull RunProfileState state, @NotNull ExecutionEnvironment environment)
throws ExecutionException {
return DefaultProgramRunnerKt.executeState(state, environment, this);
}
}

89
modules/project/src/main/java/com/falsepattern/zigbrains/project/runconfig/ZigExecutableRunner.java
View file

@ -1,89 +0,0 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.runconfig;
import com.falsepattern.zigbrains.project.execution.configurations.AbstractZigExecutionConfiguration;
import com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfigurationRunProfileState;
import com.falsepattern.zigbrains.project.openapi.components.ZigProjectSettingsService;
import com.falsepattern.zigbrains.zig.lsp.ZLSEditorEventManager;
import com.intellij.execution.DefaultExecutionResult;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.configurations.GeneralCommandLine;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.execution.configurations.RunProfileState;
import com.intellij.execution.runners.DefaultProgramRunnerKt;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.execution.ui.RunContentDescriptor;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.application.ex.ApplicationManagerEx;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import lombok.val;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public abstract class ZigExecutableRunner extends ZigDefaultProgramRunnerBase {
protected final String executorId;
private final String errorMessageTitle;
public ZigExecutableRunner(String executorId, String errorMessageTitle) {
this.executorId = executorId;
this.errorMessageTitle = errorMessageTitle;
}
@Override
public boolean canRun(@NotNull String executorId, @NotNull RunProfile profile) {
return executorId.equals(this.executorId) && profile instanceof AbstractZigExecutionConfiguration;
}
@Override
protected void execute(@NotNull ExecutionEnvironment environment, @NotNull RunProfileState state) {
super.execute(environment, state);
}
@Override
protected @Nullable RunContentDescriptor doExecute(@NotNull RunProfileState state$, @NotNull ExecutionEnvironment environment)
throws ExecutionException {
if (!(state$ instanceof ZigRunExecutionConfigurationRunProfileState state)) {
return null;
}
val toolchain = ZigProjectSettingsService.getInstance(environment.getProject()).getToolchain();
if (toolchain == null) {
return null;
}
FileDocumentManager.getInstance().saveAllDocuments();
val cli = state.getCommandLine(toolchain);
return showRunContent(state, environment, cli);
}
protected RunContentDescriptor showRunContent(ZigRunExecutionConfigurationRunProfileState state,
ExecutionEnvironment environment,
GeneralCommandLine runExecutable) throws ExecutionException {
return DefaultProgramRunnerKt.showRunContent(executeCommandLine(state, runExecutable, environment), environment);
}
private DefaultExecutionResult executeCommandLine(ZigRunExecutionConfigurationRunProfileState state,
GeneralCommandLine commandLine,
ExecutionEnvironment environment) throws ExecutionException {
return state.executeCommandLine(commandLine, environment);
}
}

70
modules/project/src/main/java/com/falsepattern/zigbrains/project/runconfig/ZigProgramRunnerBase.java Normal file
View file

@ -0,0 +1,70 @@
/*
* Copyright 2023-2024 FalsePattern
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.runconfig;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.falsepattern.zigbrains.project.openapi.components.ZigProjectSettingsService;
import com.falsepattern.zigbrains.project.toolchain.AbstractZigToolchain;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.configurations.RunProfileState;
import com.intellij.execution.configurations.RunnerSettings;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.execution.runners.GenericProgramRunner;
import com.intellij.execution.ui.RunContentDescriptor;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import lombok.val;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public abstract class ZigProgramRunnerBase<ProfileState extends ProfileStateBase<?>> extends GenericProgramRunner<RunnerSettings> {
protected final String executorId;
public ZigProgramRunnerBase(String executorId) {
this.executorId = executorId;
}
@Override
protected void execute(@NotNull ExecutionEnvironment environment, @NotNull RunProfileState state) {
super.execute(environment, state);
}
@Override
protected @Nullable RunContentDescriptor doExecute(@NotNull RunProfileState state$, @NotNull ExecutionEnvironment environment)
throws ExecutionException {
if (!(state$ instanceof ProfileStateBase<?> state$$)) {
return null;
}
val state = castProfileState(state$$);
if (state == null)
return null;
val toolchain = ZigProjectSettingsService.getInstance(environment.getProject()).getToolchain();
if (toolchain == null) {
return null;
}
FileDocumentManager.getInstance().saveAllDocuments();
return doExecute(state, toolchain, environment);
}
protected abstract @Nullable ProfileState castProfileState(ProfileStateBase<?> state);
protected abstract @Nullable RunContentDescriptor doExecute(ProfileState state,
AbstractZigToolchain toolchain,
ExecutionEnvironment environment) throws ExecutionException;
}

29
modules/project/src/main/java/com/falsepattern/zigbrains/project/runconfig/ZigRegularRunner.java
View file

@ -16,17 +16,42 @@
package com.falsepattern.zigbrains.project.runconfig;
import com.falsepattern.zigbrains.project.execution.base.ProfileStateBase;
import com.falsepattern.zigbrains.project.execution.base.ZigExecConfigBase;
import com.falsepattern.zigbrains.project.toolchain.AbstractZigToolchain;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.execution.executors.DefaultRunExecutor;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.execution.ui.RunContentDescriptor;
import com.intellij.execution.runners.DefaultProgramRunnerKt;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public class ZigRegularRunner extends ZigExecutableRunner{
public class ZigRegularRunner extends ZigProgramRunnerBase<ProfileStateBase<?>> {
public ZigRegularRunner() {
super(DefaultRunExecutor.EXECUTOR_ID, "Unable to run zig");
super(DefaultRunExecutor.EXECUTOR_ID);
}
@Override
public @NotNull @NonNls String getRunnerId() {
return "ZigRegularRunner";
}
@Override
public boolean canRun(@NotNull String executorId, @NotNull RunProfile profile) {
return this.executorId.equals(executorId) && profile instanceof ZigExecConfigBase<?>;
}
@Override
protected @Nullable ProfileStateBase<?> castProfileState(ProfileStateBase<?> state) {
return state;
}
@Override
protected @Nullable RunContentDescriptor doExecute(ProfileStateBase<?> state, AbstractZigToolchain toolchain, ExecutionEnvironment environment)
throws ExecutionException {
return DefaultProgramRunnerKt.showRunContent(state.executeCommandLine(state.getCommandLine(toolchain), environment), environment);
}
}

8
modules/project/src/main/java/com/falsepattern/zigbrains/project/toolchain/tools/AbstractZigTool.java
View file

@ -17,7 +17,9 @@
package com.falsepattern.zigbrains.project.toolchain.tools;
import com.falsepattern.zigbrains.project.toolchain.AbstractZigToolchain;
import com.falsepattern.zigbrains.project.util.CLIUtil;
import com.intellij.execution.configurations.GeneralCommandLine;
import com.intellij.execution.process.ProcessOutput;
import kotlin.text.Charsets;
import lombok.AllArgsConstructor;
import lombok.val;
@ -28,6 +30,7 @@ import java.nio.file.Path;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@AllArgsConstructor
public abstract class AbstractZigTool {
@ -38,6 +41,11 @@ public abstract class AbstractZigTool {
return toolchain.pathToExecutable(toolName);
}
public final Optional<ProcessOutput> callWithArgs(@Nullable Path workingDirectory, int timeoutMillis, String... parameters) {
return CLIUtil.execute(createBaseCommandLine(workingDirectory, parameters),
timeoutMillis);
}
protected final GeneralCommandLine createBaseCommandLine(@Nullable Path workingDirectory,
String @NotNull... parameters) {
return createBaseCommandLine(workingDirectory, Collections.emptyMap(), parameters);

7
modules/project/src/main/java/com/falsepattern/zigbrains/project/toolchain/tools/ZigCompilerTool.java
View file

@ -34,10 +34,9 @@ public class ZigCompilerTool extends AbstractZigTool{
}
public Optional<ZigToolchainEnvironmentSerializable> getEnv(@Nullable Path workingDirectory) {
return CLIUtil.execute(createBaseCommandLine(workingDirectory, "env"),
toolchain.executionTimeoutInMilliseconds())
.map(ProcessOutput::getStdoutLines)
.map(lines -> new Gson().fromJson(String.join(" ", lines), ZigToolchainEnvironmentSerializable.class));
return callWithArgs(workingDirectory, toolchain.executionTimeoutInMilliseconds(), "env")
.map(ProcessOutput::getStdoutLines)
.map(lines -> new Gson().fromJson(String.join(" ", lines), ZigToolchainEnvironmentSerializable.class));
}

2
modules/project/src/main/java/com/falsepattern/zigbrains/project/execution/configurations/ui/WorkingDirectoryComponent.java → modules/project/src/main/java/com/falsepattern/zigbrains/project/ui/WorkingDirectoryComponent.java
View file

@ -14,7 +14,7 @@
* limitations under the License.
*/
package com.falsepattern.zigbrains.project.execution.configurations.ui;
package com.falsepattern.zigbrains.project.ui;
import com.intellij.execution.ExecutionBundle;
import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory;

11
modules/project/src/main/java/com/falsepattern/zigbrains/project/ui/ZigCommandLinePanel.java → modules/project/src/main/java/com/falsepattern/zigbrains/project/ui/ZigFilePathPanel.java
View file

@ -16,16 +16,21 @@
package com.falsepattern.zigbrains.project.ui;
import com.intellij.openapi.fileChooser.FileChooserDescriptor;
import com.intellij.openapi.ui.TextBrowseFolderListener;
import com.intellij.openapi.ui.TextFieldWithBrowseButton;
import com.intellij.ui.TextAccessor;
import com.intellij.ui.components.JBTextField;
import javax.swing.JPanel;
import java.awt.BorderLayout;
public class ZigCommandLinePanel extends JPanel implements TextAccessor {
private final JBTextField textField = new JBTextField();
public ZigCommandLinePanel() {
public class ZigFilePathPanel extends JPanel implements TextAccessor {
private final TextFieldWithBrowseButton textField = new TextFieldWithBrowseButton();
public ZigFilePathPanel() {
super(new BorderLayout());
textField.addBrowseFolderListener(
new TextBrowseFolderListener(new FileChooserDescriptor(true, false, false, false, false, false)));
add(textField, BorderLayout.CENTER);
}

24
modules/project/src/main/resources/META-INF/zigbrains-project.xml
View file

@ -15,9 +15,22 @@
-->
<idea-plugin package="com.falsepattern.zigbrains.project">
<resource-bundle>zigbrains.project.Bundle</resource-bundle>
<extensions defaultExtensionNs="com.intellij">
<configurationType implementation="com.falsepattern.zigbrains.project.execution.configurations.ZigRunExecutionConfigurationType"/>
<runConfigurationProducer implementation="com.falsepattern.zigbrains.project.execution.actions.ZigRunExecutionConfigurationProducer"/>
<configurationType implementation="com.falsepattern.zigbrains.project.execution.run.ConfigTypeRun"/>
<runConfigurationProducer implementation="com.falsepattern.zigbrains.project.execution.run.ConfigProducerRun"/>
<runLineMarkerContributor language="Zig"
implementationClass="com.falsepattern.zigbrains.project.execution.run.ZigLineMarkerRun"/>
<configurationType implementation="com.falsepattern.zigbrains.project.execution.test.ConfigTypeTest"/>
<runConfigurationProducer implementation="com.falsepattern.zigbrains.project.execution.test.ConfigProducerTest"/>
<runLineMarkerContributor language="Zig"
implementationClass="com.falsepattern.zigbrains.project.execution.test.ZigLineMarkerTest"/>
<configurationType implementation="com.falsepattern.zigbrains.project.execution.build.ConfigTypeBuild"/>
<runConfigurationProducer implementation="com.falsepattern.zigbrains.project.execution.build.ConfigProducerBuild"/>
<runLineMarkerContributor language="Zig"
implementationClass="com.falsepattern.zigbrains.project.execution.build.ZigLineMarkerBuild"/>
<directoryProjectGenerator implementation="com.falsepattern.zigbrains.project.platform.ZigDirectoryProjectGenerator"/>
<newProjectWizard.language implementation="com.falsepattern.zigbrains.project.ide.newproject.ZigNewProjectWizard"/>
@ -28,11 +41,14 @@
id="com.falsepattern.zigbrains.project.ide.project.ZigProjectConfigurable"
displayName="Zig"/>
<runLineMarkerContributor language="Zig"
implementationClass="com.falsepattern.zigbrains.project.execution.linemarker.ZigAggregateLineMarkerContributor"/>
<programRunner implementation="com.falsepattern.zigbrains.project.runconfig.ZigRegularRunner"
id="ZigDebugRunner"/>
<notificationGroup displayType="BALLOON"
bundle="zigbrains.project.Bundle"
key="notif-zig-project"
id="ZigBrains.Project"/>
</extensions>
<extensions defaultExtensionNs="com.falsepattern.zigbrains">

4
modules/project/src/main/resources/project-gen/application/build.zig.template
View file

@ -16,7 +16,7 @@ pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{
.name = "untitled",
.name = "@@PROJECT_NAME@@",
.root_source_file = .{ .path = "src/main.zig" },
.target = target,
.optimize = optimize,
@ -63,4 +63,4 @@ pub fn build(b: *std.Build) void {
// running the unit tests.
const test_step = b.step("test", "Run unit tests");
test_step.dependOn(&run_exe_unit_tests.step);
}
}

2
modules/project/src/main/resources/project-gen/application/main.zig.template
View file

@ -21,4 +21,4 @@ test "simple test" {
defer list.deinit(); // try commenting this out and see if zig detects the memory leak!
try list.append(42);
try std.testing.expectEqual(@as(i32, 42), list.pop());
}
}

6
modules/project/src/main/resources/project-gen/shared/build.zig.zon.template
View file

@ -1,5 +1,5 @@
.{
.name = "untitled",
.name = "@@PROJECT_NAME@@",
// This is a [Semantic Version](https://semver.org/).
// In a future version of Zig it will be used for package deduplication.
.version = "0.0.0",
@ -43,7 +43,7 @@
// Specifies the set of files and directories that are included in this package.
// Only files and directories listed here are included in the `hash` that
// is computed for this package.
// Paths are relative to the build root. Use the empty string (``) to refer to
// Paths are relative to the build root. Use the empty string (`""`) to refer to
// the build root itself.
// A directory listed here means that all files within, recursively, are included.
.paths = .{
@ -59,4 +59,4 @@
//"LICENSE",
//"README.md",
},
}
}

6
modules/project/src/main/resources/project-gen/static/build.zig.template
View file

@ -4,7 +4,7 @@ const std = @import("std");
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.Build) void {
// Standard target options allow the person running `zig build` to choose
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for restricting supported target set are available.
@ -16,8 +16,8 @@ pub fn build(b: *std.Build) void {
const optimize = b.standardOptimizeOption(.{});
const lib = b.addStaticLibrary(.{
.name = "untitled",
// In this case, the main source file is merely a path, however, in more
.name = "@@PROJECT_NAME@@",
// In this case the main source file is merely a path, however, in more
// complicated build scripts, this could be a generated file.
.root_source_file = .{ .path = "src/root.zig" },
.target = target,

2
modules/project/src/main/resources/project-gen/static/root.zig.template
View file

@ -7,4 +7,4 @@ export fn add(a: i32, b: i32) i32 {
test "basic add functionality" {
try testing.expect(add(3, 7) == 10);
}
}

17
modules/project/src/main/resources/zigbrains/project/Bundle.properties Normal file
View file

@ -0,0 +1,17 @@
#
# Copyright 2023-2024 FalsePattern
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
notif-zig-project=Zig Project Status Notification

54
modules/zig/src/main/java/com/falsepattern/zigbrains/zig/highlighter/ZigColorSettingsPage.java
View file

@ -40,8 +40,10 @@ public class ZigColorSettingsPage implements ColorSettingsPage {
new AttributesDescriptor("Comment//Documentation", ZigSyntaxHighlighter.COMMENT_DOC),
new AttributesDescriptor("Enum//Reference", ZigSyntaxHighlighter.ENUM_REF),
new AttributesDescriptor("Enum//Declaration", ZigSyntaxHighlighter.ENUM_DECL),
new AttributesDescriptor("Enum//Member", ZigSyntaxHighlighter.ENUM_MEMBER),
new AttributesDescriptor("Error tag", ZigSyntaxHighlighter.ERROR_TAG),
new AttributesDescriptor("Enum//Member//Declaration", ZigSyntaxHighlighter.ENUM_MEMBER_DECL),
new AttributesDescriptor("Enum//Member//Reference", ZigSyntaxHighlighter.ENUM_MEMBER_REF),
new AttributesDescriptor("Error tag//Declaration", ZigSyntaxHighlighter.ERROR_TAG_DECL),
new AttributesDescriptor("Error tag//Reference", ZigSyntaxHighlighter.ERROR_TAG_REF),
new AttributesDescriptor("Function//Declaration", ZigSyntaxHighlighter.FUNCTION_DECL),
new AttributesDescriptor("Function//Declaration//Generic", ZigSyntaxHighlighter.FUNCTION_DECL_GEN),
new AttributesDescriptor("Function//Reference", ZigSyntaxHighlighter.FUNCTION_REF),
@ -49,12 +51,17 @@ public class ZigColorSettingsPage implements ColorSettingsPage {
new AttributesDescriptor("Keyword", ZigSyntaxHighlighter.KEYWORD),
new AttributesDescriptor("Label//Declaration", ZigSyntaxHighlighter.LABEL_REF),
new AttributesDescriptor("Label//Reference", ZigSyntaxHighlighter.LABEL_REF),
new AttributesDescriptor("Method//Declaration", ZigSyntaxHighlighter.METHOD_DECL),
new AttributesDescriptor("Method//Declaration//Generic", ZigSyntaxHighlighter.METHOD_DECL_GEN),
new AttributesDescriptor("Method//Reference", ZigSyntaxHighlighter.METHOD_REF),
new AttributesDescriptor("Method//Reference//Generic", ZigSyntaxHighlighter.METHOD_REF_GEN),
new AttributesDescriptor("Namespace//Declaration", ZigSyntaxHighlighter.NAMESPACE_DECL),
new AttributesDescriptor("Namespace//Reference", ZigSyntaxHighlighter.NAMESPACE_REF),
new AttributesDescriptor("Number", ZigSyntaxHighlighter.NUMBER),
new AttributesDescriptor("Operator", ZigSyntaxHighlighter.OPERATOR),
new AttributesDescriptor("Parameter", ZigSyntaxHighlighter.PARAMETER),
new AttributesDescriptor("Property", ZigSyntaxHighlighter.PROPERTY),
new AttributesDescriptor("Property//Declaration", ZigSyntaxHighlighter.PROPERTY_DECL),
new AttributesDescriptor("Property//Reference", ZigSyntaxHighlighter.PROPERTY_REF),
new AttributesDescriptor("String", ZigSyntaxHighlighter.STRING),
new AttributesDescriptor("Struct//Declaration", ZigSyntaxHighlighter.STRUCT_DECL),
new AttributesDescriptor("Struct//Reference", ZigSyntaxHighlighter.STRUCT_REF),
@ -62,8 +69,12 @@ public class ZigColorSettingsPage implements ColorSettingsPage {
new AttributesDescriptor("Type//Declaration//Generic", ZigSyntaxHighlighter.TYPE_DECL_GEN),
new AttributesDescriptor("Type//Reference", ZigSyntaxHighlighter.TYPE_REF),
new AttributesDescriptor("Type//Reference//Generic", ZigSyntaxHighlighter.TYPE_REF_GEN),
new AttributesDescriptor("Type parameter//Reference", ZigSyntaxHighlighter.TYPE_PARAM),
new AttributesDescriptor("Type parameter//Declaration", ZigSyntaxHighlighter.TYPE_PARAM_DECL),
new AttributesDescriptor("Variable//Declaration", ZigSyntaxHighlighter.VARIABLE_DECL),
new AttributesDescriptor("Variable//Declaration//Deprecated", ZigSyntaxHighlighter.VARIABLE_DECL_DEPR),
new AttributesDescriptor("Variable//Reference", ZigSyntaxHighlighter.VARIABLE_REF),
new AttributesDescriptor("Variable//Reference//Deprecated", ZigSyntaxHighlighter.VARIABLE_REF_DEPR),
};
@Nullable
@ -86,18 +97,18 @@ public class ZigColorSettingsPage implements ColorSettingsPage {
const <ns>std</ns> = @import("std");
const <enumDecl>AnEnum</enumDecl> = enum {
<enumMember>A</enumMember>,
<enumMember>B</enumMember>,
<enumMember>C</enumMember>,
<enumMemberDecl>A</enumMemberDecl>,
<enumMemberDecl>B</enumMemberDecl>,
<enumMemberDecl>C</enumMemberDecl>,
};
const <structDecl>AStruct</structDecl> = struct {
<property>fieldA</property>: <type>u32</type>,
<property>fieldB</property>: <type>u16</type>
<propertyDecl>fieldA</propertyDecl>: <type>u32</type>,
<propertyDecl>fieldB</propertyDecl>: <type>u16</type>
};
const <typeDecl>AnErrorType</typeDecl> = error {
<etag>SomeError</etag>
<etagDecl>SomeError</etagDecl>
};
pub fn <fn>main</fn>() <type>AnError</type>.SomeError!<type>void</type> {
@ -107,24 +118,24 @@ public class ZigColorSettingsPage implements ColorSettingsPage {
// stdout is for the actual output of your application, for example if you
// are implementing gzip, then only the compressed bytes should be sent to
// stdout, not any debugging messages.
const <varDecl>stdout_file</varDecl> = <ns>std</ns>.<ns>io</ns>.<fn>getStdOut</fn>().<fn>writer</fn>();
const <varDecl>stdout_file</varDecl> = <ns>std</ns>.<ns>io</ns>.<fn>getStdOut</fn>().<md>writer</md>();
var <varDecl>bw</varDecl> = <ns>std</ns>.<ns>io</ns>.<fn>bufferedWriter</fn>(<var>stdout_file</var>);
const <varDecl>stdout</varDecl> = <var>bw</var>.<fn>writer</fn>();
const <varDecl>stdout</varDecl> = <var>bw</var>.<md>writer</md>();
try <var>stdout</var>.<fn>print</fn>(\\\\Run `zig build test` to run the tests.
try <var>stdout</var>.<md>print</md>(\\\\Run `zig build test` to run the tests.
\\\\
, .{});
_ = <enum>AnEnum</enum>.<enumMember>A</enumMember>;
try <var>bw</var>.<fn>flush</fn>(); // don't forget to flush!
try <var>bw</var>.<md>flush</md>(); // don't forget to flush!
}
test "simple test" {
var <varDecl>list</varDecl> = <ns>std</ns>.<type>ArrayList</type>(<type>i32</type>).<fn>init</fn>(<ns>std</ns>.<ns>testing</ns>.<type>allocator</type>);
defer <var>list</var>.<fn>deinit</fn>(); // try commenting this out and see if zig detects the memory leak!
try <var>list</var>.<fn>append</fn>(42);
try <ns>std</ns>.<ns>testing</ns>.<fn>expectEqual</fn>(@as(i32, 42), <var>list</var>.<fn>pop</fn>());
var <varDecl>list</varDecl> = <ns>std</ns>.<type>ArrayList</type>(<type>i32</type>).<md>init</md>(<ns>std</ns>.<ns>testing</ns>.<type>allocator</type>);
defer <var>list</var>.<md>deinit</md>(); // try commenting this out and see if zig detects the memory leak!
try <var>list</var>.<md>append</md>(42);
try <ns>std</ns>.<ns>testing</ns>.<fn>expectEqual</fn>(@as(i32, 42), <var>list</var>.<md>pop</md>());
}
""";
}
@ -132,17 +143,20 @@ public class ZigColorSettingsPage implements ColorSettingsPage {
private static final Map<String, TextAttributesKey> ADD_HIGHLIGHT = new HashMap<>();
static {
ADD_HIGHLIGHT.put("typeDecl", ZigSyntaxHighlighter.TYPE_DECL);
ADD_HIGHLIGHT.put("etag", ZigSyntaxHighlighter.ERROR_TAG);
ADD_HIGHLIGHT.put("etagDecl", ZigSyntaxHighlighter.ERROR_TAG_DECL);
ADD_HIGHLIGHT.put("struct", ZigSyntaxHighlighter.STRUCT_REF);
ADD_HIGHLIGHT.put("enum", ZigSyntaxHighlighter.ENUM_REF);
ADD_HIGHLIGHT.put("enumDecl", ZigSyntaxHighlighter.ENUM_DECL);
ADD_HIGHLIGHT.put("enumMember", ZigSyntaxHighlighter.ENUM_MEMBER);
ADD_HIGHLIGHT.put("enumMember", ZigSyntaxHighlighter.ENUM_MEMBER_REF);
ADD_HIGHLIGHT.put("enumMemberDecl", ZigSyntaxHighlighter.ENUM_MEMBER_DECL);
ADD_HIGHLIGHT.put("varDecl", ZigSyntaxHighlighter.VARIABLE_DECL);
ADD_HIGHLIGHT.put("property", ZigSyntaxHighlighter.PROPERTY);
ADD_HIGHLIGHT.put("propertyDecl", ZigSyntaxHighlighter.PROPERTY_DECL);
ADD_HIGHLIGHT.put("structDecl", ZigSyntaxHighlighter.STRUCT_DECL);
ADD_HIGHLIGHT.put("var", ZigSyntaxHighlighter.VARIABLE_REF);
ADD_HIGHLIGHT.put("ns", ZigSyntaxHighlighter.NAMESPACE_REF);
ADD_HIGHLIGHT.put("type", ZigSyntaxHighlighter.TYPE_REF);
ADD_HIGHLIGHT.put("fn", ZigSyntaxHighlighter.FUNCTION_REF);
ADD_HIGHLIGHT.put("md", ZigSyntaxHighlighter.METHOD_REF);
}
@Nullable

19
modules/zig/src/main/java/com/falsepattern/zigbrains/zig/highlighter/ZigSyntaxHighlighter.java
View file

@ -41,9 +41,12 @@ public class ZigSyntaxHighlighter extends SyntaxHighlighterBase {
COMMENT_DOC = createKey("COMMENT_DOC" , DefaultLanguageHighlighterColors.DOC_COMMENT ),
ENUM_DECL = createKey("ENUM_DECL" , DefaultLanguageHighlighterColors.CLASS_NAME ),
ENUM_REF = createKey("ENUM" , DefaultLanguageHighlighterColors.CLASS_REFERENCE ),
ENUM_MEMBER = createKey("ENUM_MEMBER" , DefaultLanguageHighlighterColors.STATIC_FIELD ),
ERROR_TAG = createKey("ERROR_TAG" , DefaultLanguageHighlighterColors.STATIC_FIELD ),
PROPERTY = createKey("PROPERTY" , DefaultLanguageHighlighterColors.INSTANCE_FIELD ),
ENUM_MEMBER_DECL = createKey("ENUM_MEMBER_DECL" , DefaultLanguageHighlighterColors.STATIC_FIELD ),
ENUM_MEMBER_REF = createKey("ENUM_MEMBER" , ENUM_MEMBER_DECL ),
ERROR_TAG_DECL = createKey("ERROR_TAG_DECL" , DefaultLanguageHighlighterColors.STATIC_FIELD ),
ERROR_TAG_REF = createKey("ERROR_TAG" , ERROR_TAG_DECL ),
PROPERTY_DECL = createKey("PROPERTY_DECL" , DefaultLanguageHighlighterColors.INSTANCE_FIELD ),
PROPERTY_REF = createKey("PROPERTY" , PROPERTY_DECL ),
FUNCTION_DECL = createKey("FUNCTION_DECL" , DefaultLanguageHighlighterColors.FUNCTION_DECLARATION),
FUNCTION_DECL_GEN = createKey("FUNCTION_DECL_GEN" , FUNCTION_DECL ),
FUNCTION_REF = createKey("FUNCTION" , DefaultLanguageHighlighterColors.FUNCTION_CALL ),
@ -51,6 +54,10 @@ public class ZigSyntaxHighlighter extends SyntaxHighlighterBase {
KEYWORD = createKey("KEYWORD" , DefaultLanguageHighlighterColors.KEYWORD ),
LABEL_DECL = createKey("LABEL_DECL" , DefaultLanguageHighlighterColors.LABEL ),
LABEL_REF = createKey("LABEL" , LABEL_DECL ),
METHOD_DECL = createKey("METHOD_DECL" , FUNCTION_DECL ),
METHOD_DECL_GEN = createKey("METHOD_DECL_GEN" , METHOD_DECL ),
METHOD_REF = createKey("METHOD" , FUNCTION_REF ),
METHOD_REF_GEN = createKey("METHOD_GEN" , METHOD_REF ),
NAMESPACE_DECL = createKey("NAMESPACE_DECL" , DefaultLanguageHighlighterColors.CLASS_REFERENCE ),
NAMESPACE_REF = createKey("NAMESPACE" , DefaultLanguageHighlighterColors.CLASS_NAME ),
NUMBER = createKey("NUMBER" , DefaultLanguageHighlighterColors.NUMBER ),
@ -63,8 +70,12 @@ public class ZigSyntaxHighlighter extends SyntaxHighlighterBase {
TYPE_DECL_GEN = createKey("TYPE_DECL_GEN" , TYPE_DECL ),
TYPE_REF = createKey("TYPE" , DefaultLanguageHighlighterColors.CLASS_REFERENCE ),
TYPE_REF_GEN = createKey("TYPE_GEN" , TYPE_REF ),
TYPE_PARAM = createKey("TYPE_PARAM" , TYPE_REF ),
TYPE_PARAM_DECL = createKey("TYPE_PARAM_DECL" , TYPE_PARAM ),
VARIABLE_DECL = createKey("VARIABLE_DECL" , DefaultLanguageHighlighterColors.LOCAL_VARIABLE ),
VARIABLE_REF = createKey("VARIABLE" , VARIABLE_DECL );
VARIABLE_DECL_DEPR= createKey("VARIABLE_DECL_DEPR" , VARIABLE_DECL ),
VARIABLE_REF = createKey("VARIABLE" , VARIABLE_DECL ),
VARIABLE_REF_DEPR = createKey("VARIABLE_REF_DEPL" , VARIABLE_REF );
// @formatter:on
private static final TextAttributesKey[] EMPTY_KEYS = new TextAttributesKey[0];
private static final Map<IElementType, TextAttributesKey[]> KEYMAP = new HashMap<>();

85
modules/zig/src/main/java/com/falsepattern/zigbrains/zig/ide/ZigAttributes.java
View file

@ -16,11 +16,17 @@
package com.falsepattern.zigbrains.zig.ide;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.colors.TextAttributesKey;
import kotlin.Pair;
import lombok.val;
import org.jetbrains.annotations.Unmodifiable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
@ -28,24 +34,36 @@ import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.BU
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.COMMENT;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.COMMENT_DOC;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.ENUM_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.ENUM_MEMBER;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.ENUM_MEMBER_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.ENUM_MEMBER_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.ENUM_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.ERROR_TAG;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.ERROR_TAG_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.ERROR_TAG_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.FUNCTION_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.FUNCTION_DECL_GEN;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.FUNCTION_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.FUNCTION_REF_GEN;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.KEYWORD;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.LABEL_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.LABEL_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.METHOD_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.METHOD_DECL_GEN;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.METHOD_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.METHOD_REF_GEN;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.NAMESPACE_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.NAMESPACE_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.NUMBER;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.OPERATOR;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.PARAMETER;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.PROPERTY;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.PROPERTY_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.PROPERTY_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.STRING;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.STRUCT_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.STRUCT_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.TYPE_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.TYPE_DECL_GEN;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.TYPE_PARAM;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.TYPE_PARAM_DECL;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.TYPE_REF;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.TYPE_REF_GEN;
import static com.falsepattern.zigbrains.zig.highlighter.ZigSyntaxHighlighter.VARIABLE_DECL;
@ -58,17 +76,24 @@ public enum ZigAttributes {
Comment(COMMENT),
Enum_Decl(ENUM_DECL, "declaration"),
Enum(ENUM_REF),
EnumMember(ENUM_MEMBER),
ErrorTag(ERROR_TAG),
Property(PROPERTY),
Function_Decl_Gen(FUNCTION_REF, "declaration", "generic"),
Function_Decl(FUNCTION_REF, "declaration"),
Function_Gen(FUNCTION_REF, "generic"),
EnumMember_Decl(ENUM_MEMBER_DECL, "declaration"),
EnumMember(ENUM_MEMBER_REF),
ErrorTag_Decl(ERROR_TAG_DECL, "declaration"),
ErrorTag(ERROR_TAG_REF),
Property_Decl(PROPERTY_DECL, "declaration"),
Property(PROPERTY_REF),
Function_Decl_Gen(FUNCTION_DECL_GEN, "declaration", "generic"),
Function_Decl(FUNCTION_DECL, "declaration"),
Function_Gen(FUNCTION_REF_GEN, "generic"),
Function(FUNCTION_REF),
Keyword(KEYWORD),
KeywordLiteral(KEYWORD),
Label_Decl(LABEL_DECL, "declaration"),
Label(LABEL_REF),
Method_Decl_Gen(METHOD_DECL_GEN, "declaration", "generic"),
Method_Decl(METHOD_DECL, "declaration"),
Method_Gen(METHOD_REF_GEN, "generic"),
Method(METHOD_REF),
Namespace_Decl(NAMESPACE_DECL, "declaration"),
Namespace(NAMESPACE_REF),
Number(NUMBER),
@ -82,7 +107,11 @@ public enum ZigAttributes {
Type_Decl(TYPE_DECL, "declaration"),
Type_Gen(TYPE_REF_GEN, "generic"),
Type(TYPE_REF),
TypeParameter_Decl(TYPE_PARAM_DECL, "declaration"),
TypeParameter(TYPE_PARAM),
Variable_Decl_Depr(VARIABLE_DECL, "declaration", "deprecated"),
Variable_Decl(VARIABLE_DECL, "declaration"),
Variable_Depr(VARIABLE_REF, "deprecated"),
Variable(VARIABLE_REF),
;
public final TextAttributesKey KEY;
@ -97,13 +126,45 @@ public enum ZigAttributes {
this.modifiers = new HashSet<>(List.of(modifiers));
}
private static final Map<String, List<ZigAttributes>> types = new HashMap<>();
static {
for (val known: values()) {
types.computeIfAbsent(known.type, (ignored) -> new ArrayList<>()).add(known);
}
}
private static final Logger LOG = Logger.getInstance(ZigAttributes.class);
private static final Set<Pair<String, Set<String>>> warnedUnknowns = new HashSet<>();
private static void complainAboutUnknownCombo(String type, Set<String> modifiers) {
val thePair = new Pair<>(type, modifiers);
synchronized (warnedUnknowns) {
if (warnedUnknowns.contains(thePair))
return;
warnedUnknowns.add(thePair);
LOG.warn("Unrecognized semantic token! type " + type + ", modifiers: " + modifiers);
}
}
public static Optional<TextAttributesKey> getKey(String type, Set<String> modifiers) {
if (type == null) {
return Optional.empty();
}
for (var known : values()) {
if (known.type.equals(type) && ((modifiers != null && modifiers.containsAll(known.modifiers)) ||
(modifiers == null && known.modifiers.size() == 0))) {
if (!types.containsKey(type)) {
complainAboutUnknownCombo(type, modifiers);
return Optional.empty();
}
val values = types.get(type);
for (var known : values) {
if ((modifiers != null && modifiers.equals(known.modifiers)) ||
(modifiers == null && known.modifiers.isEmpty())) {
return Optional.of(known.KEY);
}
}
complainAboutUnknownCombo(type, modifiers);
//Fallback with weaker matching
for (var known : values) {
if ((modifiers != null && modifiers.containsAll(known.modifiers)) ||
(modifiers == null && known.modifiers.isEmpty())) {
return Optional.of(known.KEY);
}
}

2
modules/zig/src/main/java/com/falsepattern/zigbrains/zig/lsp/ZLSEditorEventManager.java
View file

@ -118,7 +118,7 @@ public class ZLSEditorEventManager extends EditorEventManager {
return () -> {
run.run();
if (!editor.isDisposed()) {
ApplicationManager.getApplication().invokeLater(() -> HighlightingUtil.refreshHighlighting(this));
HighlightingUtil.refreshHighlighting(this);
}
};
}

17
modules/zig/src/main/java/com/falsepattern/zigbrains/zig/util/HighlightingUtil.java
View file

@ -23,6 +23,7 @@ import com.intellij.openapi.application.WriteAction;
import com.intellij.openapi.editor.markup.HighlighterLayer;
import com.intellij.openapi.editor.markup.HighlighterTargetArea;
import com.intellij.openapi.util.Key;
import lombok.val;
import java.util.ArrayList;
import java.util.Comparator;
@ -61,14 +62,15 @@ public class HighlightingUtil {
.map(hl -> Map.entry(hl, hl.getStartOffset()))
.sorted(Comparator.comparingInt(Map.Entry::getValue))
.toList());
app.invokeLater(() -> {
val writes = new ArrayList<Runnable>();
app.runReadAction(() -> {
if (editor.isDisposed()) {
return;
}
if (highlightRanges.size() == 1 &&
highlightRanges.get(0).start() == 0 &&
highlightRanges.get(0).remove() == -1) {
markup.removeAllHighlighters();
writes.add(markup::removeAllHighlighters);
}
var documentLength = editor.getDocument().getTextLength();
for (var range : highlightRanges) {
@ -80,7 +82,8 @@ public class HighlightingUtil {
if (hl.getValue() >= start) {
for (int j = 0; j < toRemove; j++) {
highlightersSorted.remove(i);
markup.removeHighlighter(hl.getKey());
val key = hl.getKey();
writes.add(() -> markup.removeHighlighter(key));
}
}
}
@ -91,10 +94,14 @@ public class HighlightingUtil {
if (end > documentLength || editStart > documentLength) {
continue;
}
markup.addRangeHighlighter(edit.color(), editStart, end, HighlighterLayer.ADDITIONAL_SYNTAX,
HighlighterTargetArea.EXACT_RANGE);
val color = edit.color();
writes.add(() -> markup.addRangeHighlighter(color, editStart, end, HighlighterLayer.ADDITIONAL_SYNTAX, HighlighterTargetArea.EXACT_RANGE));
}
}
app.invokeLater(() -> {
for (val write: writes)
write.run();
});
});
});
}