/
Language.java
288 lines (253 loc) · 10.1 KB
/
Language.java
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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.lang;
import com.intellij.diagnostic.ImplementationConflictException;
import com.intellij.diagnostic.PluginException;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.extensions.DefaultPluginDescriptor;
import com.intellij.openapi.extensions.PluginDescriptor;
import com.intellij.openapi.fileTypes.FileType;
import com.intellij.openapi.fileTypes.FileTypeRegistry;
import com.intellij.openapi.fileTypes.LanguageFileType;
import com.intellij.openapi.util.NlsSafe;
import com.intellij.openapi.util.UserDataHolderBase;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
import com.intellij.psi.tree.IElementType;
import com.intellij.util.ArrayUtilRt;
import com.intellij.util.ConcurrencyUtil;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
/**
* A language represents a programming language such as Java,
* a document format such as HTML or Markdown,
* or other structured data formats such as HTTP cookies or regular expressions.
* <p>
* An implementation for a specific language should inherit from this class
* and wrap its registered instance with {@link LanguageFileType}
* via the {@code com.intellij.fileType} extension point.
* <p>
* There should be exactly one instance of each Language.
* It is usually created when creating {@link LanguageFileType} and can be retrieved later with {@link #findInstance(Class)}.
* <p>
* The language coming from file type can be changed by {@link com.intellij.psi.LanguageSubstitutor}.
*/
public abstract class Language extends UserDataHolderBase {
private static final Map<Class<? extends Language>, Language> ourRegisteredLanguages = new ConcurrentHashMap<>();
private static final ConcurrentMap<String, List<Language>> ourRegisteredMimeTypes = new ConcurrentHashMap<>();
private static final Map<String, Language> ourRegisteredIDs = new ConcurrentHashMap<>();
private final Language myBaseLanguage;
private final String myID;
private final String[] myMimeTypes;
private final List<Language> myDialects = ContainerUtil.createLockFreeCopyOnWriteList();
public static final Language ANY = new Language("") {
@Override
public String toString() {
return "Language: ANY";
}
@Override
public @Nullable LanguageFileType getAssociatedFileType() {
return null;
}
};
protected Language(@NonNls @NotNull String ID) {
this(ID, ArrayUtilRt.EMPTY_STRING_ARRAY);
}
protected Language(@NonNls @NotNull String ID, @NonNls @NotNull String @NotNull ... mimeTypes) {
this(null, ID, mimeTypes);
}
protected Language(@Nullable Language baseLanguage, @NonNls @NotNull String ID, @NonNls @NotNull String @NotNull ... mimeTypes) {
if (baseLanguage instanceof MetaLanguage) {
throw new ImplementationConflictException(
"MetaLanguage cannot be a base language.\n" +
"This language: '" + ID + "'\n" +
"Base language: '" + baseLanguage.getID() + "'",
null, this, baseLanguage
);
}
myBaseLanguage = baseLanguage;
myID = ID;
myMimeTypes = mimeTypes.length == 0 ? ArrayUtilRt.EMPTY_STRING_ARRAY : mimeTypes;
Class<? extends Language> langClass = getClass();
Language prev = ourRegisteredLanguages.putIfAbsent(langClass, this);
if (prev != null) {
throw new ImplementationConflictException("Language of '" + langClass + "' is already registered: " + prev, null, prev, this);
}
prev = ourRegisteredIDs.putIfAbsent(ID, this);
if (prev != null) {
throw new ImplementationConflictException("Language with ID '" + ID + "' is already registered: " + prev.getClass(), null, prev, this);
}
for (String mimeType : mimeTypes) {
if (StringUtil.isEmpty(mimeType)) {
continue;
}
List<Language> languagesByMimeType = ourRegisteredMimeTypes.get(mimeType);
if (languagesByMimeType == null) {
languagesByMimeType = ConcurrencyUtil.cacheOrGet(ourRegisteredMimeTypes, mimeType, ContainerUtil.createConcurrentList());
}
languagesByMimeType.add(this);
}
if (baseLanguage != null) {
baseLanguage.myDialects.add(this);
}
}
/**
* @return collection of all languages registered so far.
*/
public static @NotNull Collection<Language> getRegisteredLanguages() {
Collection<Language> languages = ourRegisteredLanguages.values();
return Collections.unmodifiableCollection(new ArrayList<>(languages));
}
@ApiStatus.Internal
public static void unregisterAllLanguagesIn(@NotNull ClassLoader classLoader, @NotNull PluginDescriptor pluginDescriptor) {
for (Map.Entry<Class<? extends Language>, Language> e : new ArrayList<>(ourRegisteredLanguages.entrySet())) {
Class<? extends Language> clazz = e.getKey();
Language language = e.getValue();
if (clazz.getClassLoader() == classLoader) {
language.unregisterLanguage(pluginDescriptor);
}
}
IElementType.unregisterElementTypes(classLoader, pluginDescriptor);
}
/**
* @deprecated do not use
*/
@ApiStatus.Internal
@ApiStatus.ScheduledForRemoval
@Deprecated
public static void unregisterLanguage(@NotNull Language language) {
PluginException.reportDeprecatedUsage("this method", "");
language.unregisterLanguage(new DefaultPluginDescriptor("unknown"));
}
@ApiStatus.Internal
public void unregisterLanguage(@NotNull PluginDescriptor pluginDescriptor) {
IElementType.unregisterElementTypes(this, pluginDescriptor);
ReferenceProvidersRegistry referenceProvidersRegistry = ApplicationManager.getApplication().getServiceIfCreated(ReferenceProvidersRegistry.class);
if (referenceProvidersRegistry != null) {
referenceProvidersRegistry.unloadProvidersFor(this);
}
ourRegisteredLanguages.remove(getClass());
ourRegisteredIDs.remove(getID());
for (String mimeType : getMimeTypes()) {
ourRegisteredMimeTypes.remove(mimeType);
}
Language baseLanguage = getBaseLanguage();
if (baseLanguage != null) {
baseLanguage.unregisterDialect(this);
}
}
@ApiStatus.Internal
public void unregisterDialect(@NotNull Language language) {
myDialects.remove(language);
}
/**
* @param klass {@code java.lang.Class} of the particular language. Serves key purpose.
* @return instance of the {@code klass} language registered if any.
*/
public static <T extends Language> T findInstance(@NotNull Class<T> klass) {
//noinspection unchecked
return (T)ourRegisteredLanguages.get(klass);
}
/**
* @param mimeType of the particular language.
* @return collection of all languages for the given {@code mimeType}.
*/
public static @NotNull Collection<Language> findInstancesByMimeType(@Nullable String mimeType) {
List<Language> result = mimeType == null ? null : ourRegisteredMimeTypes.get(mimeType);
return result == null ? Collections.emptyList() : Collections.unmodifiableCollection(result);
}
@Override
public String toString() {
return "Language: " + myID;
}
/**
* Returns the list of MIME types corresponding to the language. The language MIME type is used for specifying the base language
* of a JSP page.
*
* @return The list of MIME types.
*/
public String @NotNull [] getMimeTypes() {
return myMimeTypes;
}
/**
* Returns a user-readable name of the language (language names are not localized).
*
* @return the name of the language.
*/
public @NotNull @NlsSafe String getID() {
return myID;
}
public @Nullable LanguageFileType getAssociatedFileType() {
return FileTypeRegistry.getInstance().findFileTypeByLanguage(this);
}
@ApiStatus.Internal
public @Nullable LanguageFileType findMyFileType(FileType @NotNull [] types) {
for (FileType fileType : types) {
if (fileType instanceof LanguageFileType) {
LanguageFileType languageFileType = (LanguageFileType)fileType;
if (languageFileType.getLanguage() == this && !languageFileType.isSecondary()) {
return languageFileType;
}
}
}
for (FileType fileType : types) {
if (fileType instanceof LanguageFileType) {
LanguageFileType languageFileType = (LanguageFileType)fileType;
if (isKindOf(languageFileType.getLanguage()) && !languageFileType.isSecondary()) {
return languageFileType;
}
}
}
return null;
}
public @Nullable Language getBaseLanguage() {
return myBaseLanguage;
}
public @NotNull @NlsSafe String getDisplayName() {
return getID();
}
public final boolean is(Language another) {
return this == another;
}
/**
* @return whether identifiers in this language are case-sensitive. By default, delegates to the base language (if present) or returns false (otherwise).
*/
public boolean isCaseSensitive() {
return myBaseLanguage != null && myBaseLanguage.isCaseSensitive();
}
@Contract(pure = true)
public final boolean isKindOf(Language another) {
Language l = this;
while (l != null) {
if (l.is(another)) return true;
l = l.getBaseLanguage();
}
return false;
}
public final boolean isKindOf(@NotNull @NonNls String anotherLanguageId) {
Language l = this;
while (l != null) {
if (l.getID().equals(anotherLanguageId)) return true;
l = l.getBaseLanguage();
}
return false;
}
public @NotNull List<Language> getDialects() {
return myDialects;
}
public static @Nullable Language findLanguageByID(@NonNls String id) {
return id == null ? null : ourRegisteredIDs.get(id);
}
/** Fake language identifier without registering */
protected Language(@NotNull String ID, @SuppressWarnings("UnusedParameters") boolean register) {
Language language = findLanguageByID(ID);
if (language != null) {
throw new IllegalArgumentException("Language with ID="+ID+" already registered: "+language+"; "+language.getClass());
}
myID = ID;
myBaseLanguage = null;
myMimeTypes = null;
}
}