1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
# Language Server for Java using the [Java Compiler API](https://docs.oracle.com/javase/7/docs/api/javax/tools/JavaCompiler.html)
Provides Java support using the Java Compiler API.
Requires that you have Java 8 installed on your system.
## Installation
[Install from the VS Code marketplace](https://marketplace.visualstudio.com/items?itemName=georgewfraser.vscode-javac)
## [Issues](https://github.com/georgewfraser/vscode-javac/issues)
## Features
### Javadoc
### Signature help
### Autocomplete symbols (with auto-import)
### Autocomplete members
### Go-to-definition
### Find symbols
### Lint
### Type information on hover
### Code actions
### Find references
## Usage
VSCode will provide autocomplete and help text using:
* .java files anywhere in your workspace
* Java platform classes
* External dependencies specified using `pom.xml`, Bazel, or [settings](#Settings)
## Settings
If VSCode doesn't detect your external dependencies automatically,
you can specify your external dependencies using [.vscode/settings.json](https://code.visualstudio.com/docs/getstarted/settings)
```json
{
"java.externalDependencies": [
"junit:junit:jar:4.12:test", // Maven format
"junit:junit:4.12" // Gradle-style format is also allowed
]
}
```
If all else fails, you can specify the java class path manually:
```json
{
"java.classPath": [
"lib/some-dependency.jar"
]
}
```
You can generate a list of external dependencies using your build tool:
* Maven: `mvn dependency:list`
* Gradle: `gradle dependencies`
The Java language server will look for the dependencies you specify in `java.externalDependencies` in your Maven and Gradle caches `~/.m2` and `~/.gradle`.
You should use your build tool to download the library *and* source jars of all your dependencies so that the Java language server can find them:
* Maven
* `mvn dependency:resolve` for compilation and autocomplete
* `mvn dependency:resolve -Dclassifier=sources` for inline Javadoc help
* Gradle
* `gradle dependencies` for compilation and autocomplete
* Include `classifier: sources` in your build.gradle for inline Javadoc help, for example:
```
dependencies {
testCompile group: 'junit', name: 'junit', version: '4.+'
testCompile group: 'junit', name: 'junit', version: '4.+', classifier: 'sources'
}
```
### Optional settings
Optional user settings. These should be set in global settings `Preferences -> Settings`, not in your project directory.
* `java.home` Installation directory of Java 8
## javaconfig.json is depecated
Configuration using a `javaconfig.json` file in your workspace is deprecated;
please switch to [settings.json](#Settings).
If you have a use case that cannot be supported using `settings.json` please [create an issue](https://github.com/georgewfraser/vscode-javac/issues);
## Directory structure
### Java service process
A java process that does the hard work of parsing and analyzing .java source files.
pom.xml (maven project file)
src/ (java sources)
repo/ (tools.jar packaged in a local maven repo)
target/ (compiled java .class files, .jar archives)
target/fat-jar.jar (single jar that needs to be distributed with extension)
### Typescript Visual Studio Code extension
"Glue code" that launches the external java process
and connects to it using [vscode-languageclient](https://www.npmjs.com/package/vscode-languageclient).
package.json (node package file)
tsconfig.json (typescript compilation configuration file)
tsd.json (project file for tsd, a type definitions manager)
lib/ (typescript sources)
out/ (compiled javascript)
## Design
This extension consists of an external java process,
which communicates with vscode using the [language server protocol](https://github.com/Microsoft/vscode-languageserver-protocol).
### Java service process
The java service process uses the implementation of the Java compiler in tools.jar,
which is a part of the JDK.
When VS Code needs to lint a file, perform autocomplete,
or some other task that requires Java code insight,
the java service process invokes the Java compiler programatically,
then intercepts the data structures the Java compiler uses to represent source trees and types.
### Incremental updates
The Java compiler isn't designed for incremental parsing and analysis.
However, it is *extremely* fast, so recompiling a single file gives good performance,
as long as we don't also recompile all of its dependencies.
We cache the .class files that are generated during compilation in a temporary folder,
and use those .class files instead of .java sources whenever they are up-to-date.
## Logs
The java service process will output a log file to stdout, which is visible using View / Output.
## Contributing
If you have npm and maven installed,
you should be able to install locally using
npm install -g vsce
npm install
./scripts/install.sh
|
