diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/completion/WordCompletionTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/completion/WordCompletionTest.java index b3470a01e3e3..87bbd9b94ad6 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/completion/WordCompletionTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/completion/WordCompletionTest.java @@ -1,7 +1,9 @@ package com.intellij.codeInsight.completion; import com.intellij.JavaTestUtil; +import com.intellij.lang.StdLanguages; import com.intellij.psi.*; +import com.intellij.psi.impl.source.resolve.reference.PsiReferenceRegistrarImpl; import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry; import com.intellij.util.ProcessingContext; import org.jetbrains.annotations.NotNull; @@ -68,16 +70,18 @@ public class WordCompletionTest extends CompletionTestCase { }}; } }; + PsiReferenceRegistrarImpl registrar = + (PsiReferenceRegistrarImpl)ReferenceProvidersRegistry.getInstance().getRegistrar(StdLanguages.JAVA); try { - ReferenceProvidersRegistry.getInstance().registerReferenceProvider(PsiLiteralExpression.class, softProvider); - ReferenceProvidersRegistry.getInstance().registerReferenceProvider(PsiLiteralExpression.class, hardProvider); + registrar.registerReferenceProvider(PsiLiteralExpression.class, softProvider); + registrar.registerReferenceProvider(PsiLiteralExpression.class, hardProvider); configureByFile(BASE_PATH + "3.java"); checkResultByFile(BASE_PATH + "3_after.java"); } finally { - ReferenceProvidersRegistry.getInstance().unregisterReferenceProvider(PsiLiteralExpression.class, softProvider); - ReferenceProvidersRegistry.getInstance().unregisterReferenceProvider(PsiLiteralExpression.class, hardProvider); + registrar.unregisterReferenceProvider(PsiLiteralExpression.class, softProvider); + registrar.unregisterReferenceProvider(PsiLiteralExpression.class, hardProvider); } } diff --git a/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/PsiReferenceContributorEP.java b/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/PsiReferenceContributorEP.java new file mode 100644 index 000000000000..94f91b6f73d6 --- /dev/null +++ b/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/PsiReferenceContributorEP.java @@ -0,0 +1,57 @@ +/* + * Copyright 2000-2011 JetBrains s.r.o. + * + * 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.intellij.psi.impl.source.resolve.reference; + +import com.intellij.lang.Language; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.extensions.CustomLoadingExtensionPointBean; +import com.intellij.openapi.util.NotNullLazyValue; +import com.intellij.psi.PsiReferenceContributor; +import com.intellij.util.KeyedLazyInstance; +import com.intellij.util.xmlb.annotations.Attribute; +import org.jetbrains.annotations.NotNull; + +/** + * @author Dmitry Avdeev + */ +public class PsiReferenceContributorEP extends CustomLoadingExtensionPointBean implements KeyedLazyInstance { + + @Attribute("language") + public String language = Language.ANY.getID(); + + @Attribute("implementation") + public String implementationClass; + + private final NotNullLazyValue myHandler = new NotNullLazyValue() { + @NotNull + protected PsiReferenceContributor compute() { + try { + return (PsiReferenceContributor)instantiateExtension(implementationClass, ApplicationManager.getApplication().getPicoContainer()); + } + catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + } + }; + + public PsiReferenceContributor getInstance() { + return myHandler.getValue(); + } + + public String getKey() { + return language; + } +} diff --git a/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/PsiReferenceRegistrarImpl.java b/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/PsiReferenceRegistrarImpl.java new file mode 100644 index 000000000000..f6781d69cb84 --- /dev/null +++ b/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/PsiReferenceRegistrarImpl.java @@ -0,0 +1,184 @@ +/* + * Copyright 2000-2011 JetBrains s.r.o. + * + * 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.intellij.psi.impl.source.resolve.reference; + +import com.intellij.openapi.util.Trinity; +import com.intellij.patterns.*; +import com.intellij.pom.references.PomReferenceProvider; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiReferenceProvider; +import com.intellij.psi.PsiReferenceRegistrar; +import com.intellij.psi.PsiReferenceService; +import com.intellij.psi.filters.ElementFilter; +import com.intellij.psi.filters.position.FilterPattern; +import com.intellij.util.ArrayUtil; +import com.intellij.util.ConcurrencyUtil; +import com.intellij.util.ProcessingContext; +import com.intellij.util.SmartList; +import com.intellij.util.containers.ConcurrentFactoryMap; +import com.intellij.util.containers.ConcurrentHashMap; +import com.intellij.util.containers.FactoryMap; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.*; +import java.util.concurrent.ConcurrentMap; + +/** + * @author Dmitry Avdeev + */ +public class PsiReferenceRegistrarImpl extends PsiReferenceRegistrar { + + private final ConcurrentMap myBindingsMap = new ConcurrentHashMap(); + private final ConcurrentMap myNamedBindingsMap = new ConcurrentHashMap(); + private final FactoryMap> myKnownSupers = new ConcurrentFactoryMap>() { + @Override + protected List create(Class key) { + final Set result = new LinkedHashSet(); + for (Class candidate : myBindingsMap.keySet()) { + if (candidate.isAssignableFrom(key)) { + result.add(candidate); + } + } + for (Class candidate : myNamedBindingsMap.keySet()) { + if (candidate.isAssignableFrom(key)) { + result.add(candidate); + } + } + if (result.isEmpty()) { + return Collections.emptyList(); + } + return new ArrayList(result); + } + }; + + /** + * @deprecated {@see com.intellij.psi.PsiReferenceContributor + */ + public void registerReferenceProvider(@Nullable ElementFilter elementFilter, + @NotNull Class scope, + @NotNull PsiReferenceProvider provider, + double priority) { + registerReferenceProvider(PlatformPatterns.psiElement(scope).and(new FilterPattern(elementFilter)), provider, priority); + } + + public void registerReferenceProvider(@NotNull ElementPattern pattern, + @NotNull PomReferenceProvider provider, + double priority) { + } + + public void registerReferenceProvider(@NotNull ElementPattern pattern, + @NotNull PsiReferenceProvider provider, + double priority) { + myKnownSupers.clear(); // we should clear the cache + final Class scope = pattern.getCondition().getInitialCondition().getAcceptedClass(); + final List> conditions = pattern.getCondition().getConditions(); + for (int i = 0, conditionsSize = conditions.size(); i < conditionsSize; i++) { + PatternCondition _condition = conditions.get(i); + if (_condition instanceof PsiNamePatternCondition) { + final PsiNamePatternCondition nameCondition = (PsiNamePatternCondition)_condition; + List> conditions1 = nameCondition.getNamePattern().getCondition().getConditions(); + for (int i1 = 0, conditions1Size = conditions1.size(); i1 < conditions1Size; i1++) { + PatternCondition condition = conditions1.get(i1); + if (condition instanceof ValuePatternCondition) { + final Collection strings = ((ValuePatternCondition)condition).getValues(); + registerNamedReferenceProvider(ArrayUtil.toStringArray(strings), nameCondition, scope, true, provider, priority, pattern); + return; + } + if (condition instanceof CaseInsensitiveValuePatternCondition) { + final String[] strings = ((CaseInsensitiveValuePatternCondition)condition).getValues(); + registerNamedReferenceProvider(strings, nameCondition, scope, false, provider, priority, pattern); + return; + } + } + break; + } + } + + while (true) { + final SimpleProviderBinding providerBinding = myBindingsMap.get(scope); + if (providerBinding != null) { + providerBinding.registerProvider(provider, pattern, priority); + return; + } + + final SimpleProviderBinding binding = new SimpleProviderBinding(); + binding.registerProvider(provider, pattern, priority); + if (myBindingsMap.putIfAbsent(scope, binding) == null) break; + } + } + + /** + * @deprecated {@link com.intellij.psi.PsiReferenceContributor} + */ + public void registerReferenceProvider(@Nullable ElementFilter elementFilter, + @NotNull Class scope, + @NotNull PsiReferenceProvider provider) { + registerReferenceProvider(elementFilter, scope, provider, DEFAULT_PRIORITY); + } + + public void unregisterReferenceProvider(@NotNull Class scope, @NotNull PsiReferenceProvider provider) { + final ProviderBinding providerBinding = myBindingsMap.get(scope); + providerBinding.unregisterProvider(provider); + } + + + private void registerNamedReferenceProvider(final String[] names, final PsiNamePatternCondition nameCondition, + final Class scopeClass, + final boolean caseSensitive, + final PsiReferenceProvider provider, final double priority, final ElementPattern pattern) { + NamedObjectProviderBinding providerBinding = myNamedBindingsMap.get(scopeClass); + + if (providerBinding == null) { + providerBinding = ConcurrencyUtil.cacheOrGet(myNamedBindingsMap, scopeClass, new NamedObjectProviderBinding() { + protected String getName(final PsiElement position) { + return nameCondition.getPropertyValue(position); + } + }); + } + + providerBinding.registerProvider(names, pattern, caseSensitive, provider, priority); + } + + /** + * @see com.intellij.psi.PsiReferenceContributor + * @deprecated + */ + public void registerReferenceProvider(@NotNull Class scope, @NotNull PsiReferenceProvider provider) { + registerReferenceProvider(null, scope, provider); + } + + @NotNull + List> getPairsByElement(@NotNull PsiElement element, + @NotNull PsiReferenceService.Hints hints) { + final Class clazz = element.getClass(); + List> ret = null; + for (final Class aClass : myKnownSupers.get(clazz)) { + final SimpleProviderBinding simpleBinding = myBindingsMap.get(aClass); + final NamedObjectProviderBinding namedBinding = myNamedBindingsMap.get(aClass); + if (simpleBinding == null && namedBinding == null) continue; + + if (ret == null) ret = new SmartList>(); + if (simpleBinding != null) { + simpleBinding.addAcceptableReferenceProviders(element, ret, hints); + } + if (namedBinding != null) { + namedBinding.addAcceptableReferenceProviders(element, ret, hints); + } + } + return ret == null ? Collections.>emptyList() : ret; + } +} diff --git a/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/ReferenceProvidersRegistry.java b/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/ReferenceProvidersRegistry.java index 5892762cba8d..868ab97bc056 100644 --- a/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/ReferenceProvidersRegistry.java +++ b/platform/lang-impl/src/com/intellij/psi/impl/source/resolve/reference/ReferenceProvidersRegistry.java @@ -16,30 +16,23 @@ package com.intellij.psi.impl.source.resolve.reference; -import com.intellij.codeInsight.completion.LegacyCompletionContributor; +import com.intellij.lang.Language; +import com.intellij.lang.LanguageExtension; import com.intellij.openapi.components.ServiceManager; -import com.intellij.openapi.extensions.Extensions; import com.intellij.openapi.progress.ProgressManager; import com.intellij.openapi.project.IndexNotReadyException; import com.intellij.openapi.util.Trinity; -import com.intellij.patterns.*; -import com.intellij.pom.references.PomReferenceProvider; import com.intellij.psi.*; -import com.intellij.psi.filters.ElementFilter; -import com.intellij.psi.filters.position.FilterPattern; -import com.intellij.util.ArrayUtil; -import com.intellij.util.ConcurrencyUtil; import com.intellij.util.ProcessingContext; import com.intellij.util.SmartList; -import com.intellij.util.containers.ConcurrentFactoryMap; -import com.intellij.util.containers.ConcurrentHashMap; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.containers.FactoryMap; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import java.util.*; -import java.util.concurrent.ConcurrentMap; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Map; /** * Created by IntelliJ IDEA. @@ -48,30 +41,9 @@ import java.util.concurrent.ConcurrentMap; * Time: 17:13:45 * To change this template use Options | File Templates. */ -public class ReferenceProvidersRegistry extends PsiReferenceRegistrar { - private static final PsiReferenceContributor[] ourExtensions = Extensions.getExtensions(PsiReferenceContributor.EP_NAME); - private final ConcurrentMap myBindingsMap = new ConcurrentHashMap(); - private final ConcurrentMap myNamedBindingsMap = new ConcurrentHashMap(); - private final FactoryMap> myKnownSupers = new ConcurrentFactoryMap>() { - @Override - protected List create(Class key) { - final Set result = new LinkedHashSet(); - for (Class candidate : myBindingsMap.keySet()) { - if (candidate.isAssignableFrom(key)) { - result.add(candidate); - } - } - for (Class candidate : myNamedBindingsMap.keySet()) { - if (candidate.isAssignableFrom(key)) { - result.add(candidate); - } - } - if (result.isEmpty()) { - return Collections.emptyList(); - } - return new ArrayList(result); - } - }; +public class ReferenceProvidersRegistry { + + private static final LanguageExtension EXTENSION = new LanguageExtension(PsiReferenceContributor.EP_NAME.getName()); private static final Comparator> PRIORITY_COMPARATOR = new Comparator>() { @@ -81,131 +53,25 @@ public class ReferenceProvidersRegistry extends PsiReferenceRegistrar { } }; + @SuppressWarnings({"MismatchedQueryAndUpdateOfCollection"}) + private final static Map ourRegistrars = new FactoryMap() { + @Override + protected PsiReferenceRegistrarImpl create(Language language) { + PsiReferenceRegistrarImpl registrar = new PsiReferenceRegistrarImpl(); + List contributors = EXTENSION.allForLanguage(language); + for (PsiReferenceContributor contributor : contributors) { + contributor.registerReferenceProviders(registrar); + } + return registrar; + } + }; + public static ReferenceProvidersRegistry getInstance() { return ServiceManager.getService(ReferenceProvidersRegistry.class); } - public ReferenceProvidersRegistry() { - for (final PsiReferenceContributor contributor : ourExtensions) { - contributor.registerReferenceProviders(this); - } - } - - /** - * @deprecated {@see com.intellij.psi.PsiReferenceContributor - */ - public void registerReferenceProvider(@Nullable ElementFilter elementFilter, - @NotNull Class scope, - @NotNull PsiReferenceProvider provider, - double priority) { - registerReferenceProvider(PlatformPatterns.psiElement(scope).and(new FilterPattern(elementFilter)), provider, priority); - } - - public void registerReferenceProvider(@NotNull ElementPattern pattern, - @NotNull PomReferenceProvider provider, - double priority) { - } - - public void registerReferenceProvider(@NotNull ElementPattern pattern, - @NotNull PsiReferenceProvider provider, - double priority) { - myKnownSupers.clear(); - final Class scope = pattern.getCondition().getInitialCondition().getAcceptedClass(); - final List> conditions = pattern.getCondition().getConditions(); - for (int i = 0, conditionsSize = conditions.size(); i < conditionsSize; i++) { - PatternCondition _condition = conditions.get(i); - if (_condition instanceof PsiNamePatternCondition) { - final PsiNamePatternCondition nameCondition = (PsiNamePatternCondition)_condition; - List> conditions1 = nameCondition.getNamePattern().getCondition().getConditions(); - for (int i1 = 0, conditions1Size = conditions1.size(); i1 < conditions1Size; i1++) { - PatternCondition condition = conditions1.get(i1); - if (condition instanceof ValuePatternCondition) { - final Collection strings = ((ValuePatternCondition)condition).getValues(); - registerNamedReferenceProvider(ArrayUtil.toStringArray(strings), nameCondition, scope, true, provider, priority, pattern); - return; - } - if (condition instanceof CaseInsensitiveValuePatternCondition) { - final String[] strings = ((CaseInsensitiveValuePatternCondition)condition).getValues(); - registerNamedReferenceProvider(strings, nameCondition, scope, false, provider, priority, pattern); - return; - } - } - break; - } - } - - while (true) { - final SimpleProviderBinding providerBinding = myBindingsMap.get(scope); - if (providerBinding != null) { - providerBinding.registerProvider(provider, pattern, priority); - return; - } - - final SimpleProviderBinding binding = new SimpleProviderBinding(); - binding.registerProvider(provider, pattern, priority); - if (myBindingsMap.putIfAbsent(scope, binding) == null) break; - } - } - - /** - * @deprecated {@link com.intellij.psi.PsiReferenceContributor} - */ - public void registerReferenceProvider(@Nullable ElementFilter elementFilter, - @NotNull Class scope, - @NotNull PsiReferenceProvider provider) { - registerReferenceProvider(elementFilter, scope, provider, DEFAULT_PRIORITY); - } - - public void unregisterReferenceProvider(@NotNull Class scope, @NotNull PsiReferenceProvider provider) { - final ProviderBinding providerBinding = myBindingsMap.get(scope); - providerBinding.unregisterProvider(provider); - } - - - private void registerNamedReferenceProvider(final String[] names, final PsiNamePatternCondition nameCondition, - final Class scopeClass, - final boolean caseSensitive, - final PsiReferenceProvider provider, final double priority, final ElementPattern pattern) { - NamedObjectProviderBinding providerBinding = myNamedBindingsMap.get(scopeClass); - - if (providerBinding == null) { - providerBinding = ConcurrencyUtil.cacheOrGet(myNamedBindingsMap, scopeClass, new NamedObjectProviderBinding() { - protected String getName(final PsiElement position) { - return nameCondition.getPropertyValue(position); - } - }); - } - - providerBinding.registerProvider(names, pattern, caseSensitive, provider, priority); - } - - /** - * @see com.intellij.psi.PsiReferenceContributor - * @deprecated - */ - public void registerReferenceProvider(@NotNull Class scope, @NotNull PsiReferenceProvider provider) { - registerReferenceProvider(null, scope, provider); - } - - @NotNull - private List> getPairsByElement(@NotNull PsiElement element, - @NotNull PsiReferenceService.Hints hints) { - final Class clazz = element.getClass(); - List> ret = null; - for (final Class aClass : myKnownSupers.get(clazz)) { - final SimpleProviderBinding simpleBinding = myBindingsMap.get(aClass); - final NamedObjectProviderBinding namedBinding = myNamedBindingsMap.get(aClass); - if (simpleBinding == null && namedBinding == null) continue; - - if (ret == null) ret = new SmartList>(); - if (simpleBinding != null) { - simpleBinding.addAcceptableReferenceProviders(element, ret, hints); - } - if (namedBinding != null) { - namedBinding.addAcceptableReferenceProviders(element, ret, hints); - } - } - return ret == null ? Collections.>emptyList() : ret; + public PsiReferenceRegistrar getRegistrar(Language language) { + return ourRegistrars.get(language); } @Deprecated @@ -217,8 +83,10 @@ public class ReferenceProvidersRegistry extends PsiReferenceRegistrar { ProgressManager.checkCanceled(); assert context.isValid() : "Invalid context: " + context; - final List> providers = - getInstance().getPairsByElement(context, hints); + PsiReferenceRegistrarImpl registrar = ourRegistrars.get(context.getLanguage()); + SmartList> providers = new SmartList>(); + providers.addAll(registrar.getPairsByElement(context, hints)); + providers.addAll(ourRegistrars.get(Language.ANY).getPairsByElement(context, hints)); if (providers.isEmpty()) { return PsiReference.EMPTY_ARRAY; } @@ -228,12 +96,7 @@ public class ReferenceProvidersRegistry extends PsiReferenceRegistrar { return firstProvider.getFirst().getReferencesByElement(context, firstProvider.getSecond()); } - ((SmartList>)providers).sort(PRIORITY_COMPARATOR); - - if (LegacyCompletionContributor.DEBUG) { - System.out.println("ReferenceProvidersRegistry.getReferencesFromProviders"); - System.out.println("providers = " + providers); - } + providers.sort(PRIORITY_COMPARATOR); List result = new ArrayList(); final double maxPriority = providers.get(0).getThird(); diff --git a/platform/platform-resources/src/META-INF/LangExtensionPoints.xml b/platform/platform-resources/src/META-INF/LangExtensionPoints.xml index 43d74cb2eed8..990b69e8b29a 100644 --- a/platform/platform-resources/src/META-INF/LangExtensionPoints.xml +++ b/platform/platform-resources/src/META-INF/LangExtensionPoints.xml @@ -266,7 +266,7 @@ - + diff --git a/plugins/IntelliLang/java-support/org/intellij/plugins/intelliLang/inject/java/LanguageReferenceProvider.java b/plugins/IntelliLang/java-support/org/intellij/plugins/intelliLang/inject/java/LanguageReferenceProvider.java index 444f0934fe95..e8f36cab82d6 100644 --- a/plugins/IntelliLang/java-support/org/intellij/plugins/intelliLang/inject/java/LanguageReferenceProvider.java +++ b/plugins/IntelliLang/java-support/org/intellij/plugins/intelliLang/inject/java/LanguageReferenceProvider.java @@ -18,19 +18,20 @@ package org.intellij.plugins.intelliLang.inject.java; import com.intellij.openapi.util.Comparing; import com.intellij.openapi.util.Computable; import com.intellij.patterns.PatternCondition; -import static com.intellij.patterns.PsiJavaPatterns.literalExpression; import com.intellij.patterns.StandardPatterns; import com.intellij.psi.*; import com.intellij.util.ProcessingContext; import org.intellij.plugins.intelliLang.Configuration; -import org.intellij.plugins.intelliLang.util.PsiUtilEx; import org.intellij.plugins.intelliLang.util.AnnotationUtilEx; +import org.intellij.plugins.intelliLang.util.PsiUtilEx; import org.jetbrains.annotations.NotNull; +import static com.intellij.patterns.PsiJavaPatterns.literalExpression; + /** * Provides references to Language-IDs and RegExp enums for completion. */ -final class LanguageReferenceProvider extends PsiReferenceContributor { +public final class LanguageReferenceProvider extends PsiReferenceContributor { private final Configuration myConfig = Configuration.getInstance(); private final Computable ANNOTATION_NAME = new Computable() { diff --git a/plugins/testng/src/META-INF/plugin.xml b/plugins/testng/src/META-INF/plugin.xml index fc2c23df4fd4..37bd6dc007fe 100644 --- a/plugins/testng/src/META-INF/plugin.xml +++ b/plugins/testng/src/META-INF/plugin.xml @@ -13,7 +13,7 @@ - + com.theoryinpractice.testng.intention.TestNGOrderEntryFix diff --git a/plugins/ui-designer/src/META-INF/plugin.xml b/plugins/ui-designer/src/META-INF/plugin.xml index c14277c05805..e77dfbd6437c 100644 --- a/plugins/ui-designer/src/META-INF/plugin.xml +++ b/plugins/ui-designer/src/META-INF/plugin.xml @@ -104,7 +104,7 @@ - + diff --git a/plugins/xpath/xpath-view/src/META-INF/plugin.xml b/plugins/xpath/xpath-view/src/META-INF/plugin.xml index dd6cdb0ab447..5e3d671cf0e3 100644 --- a/plugins/xpath/xpath-view/src/META-INF/plugin.xml +++ b/plugins/xpath/xpath-view/src/META-INF/plugin.xml @@ -133,7 +133,7 @@ - + diff --git a/xml/dom-impl/src/META-INF/DomPlugin.xml b/xml/dom-impl/src/META-INF/DomPlugin.xml index 30f0fa8a873a..561d5a1a10bd 100644 --- a/xml/dom-impl/src/META-INF/DomPlugin.xml +++ b/xml/dom-impl/src/META-INF/DomPlugin.xml @@ -58,7 +58,7 @@ - +