openide/plugins/groovy/src/META-INF/plugin.xml

<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude" package="org.jetbrains.plugins.groovy">
  <id>org.intellij.groovy</id>
  <name>Groovy</name>
  <category>Languages</category>
  <description><![CDATA[
  Adds support for the <a href="https://groovy-lang.org/">Groovy</b> language.
   <ul>
     <li>Coding assistance: code completion, inspections, refactorings, quick documentation, and much more</li>
     <li>Interactive Groovy console to evaluate code expressions without compilation: <b>Tools | Groovy Console</b></li>
     <li>Support for the <a href="https://docs.groovy-lang.org/latest/html/documentation/grape.html">Grape</a> dependency manager and
     <a href="https://gant.github.io/">Gant</a> for scripting Ant tasks using Groovy</li>
   </ul>
  ]]></description>
  <vendor>JetBrains</vendor>

  <content>
    <module name="intellij.groovy.git"/>
    <module name="intellij.groovy/ant"/>
    <module name="intellij.groovy/byte-code-viewer"/>
  </content>
  <dependencies>
    <plugin id="com.intellij.properties"/>
    <plugin id="com.intellij.java"/>
  </dependencies>

  <depends optional="true" config-file="groovy-copyright.xml">com.intellij.copyright</depends>
  <depends optional="true" config-file="intellilang-groovy-support.xml">org.intellij.intelliLang</depends>
  <!--suppress PluginXmlValidity -->
  <depends optional="true" config-file="duplicates-groovy.xml">com.intellij.modules.ultimate</depends>
  <!--suppress PluginXmlValidity -->
  <depends optional="true" config-file="duplicates-detection-groovy.xml">com.intellij.modules.duplicatesDetector</depends>
  <!--suppress PluginXmlValidity -->
  <depends optional="true" config-file="groovy-structural-search.xml">com.intellij.modules.structuralsearch</depends>
  <depends optional="true" config-file="spock-support.xml">JUnit</depends>

  <resource-bundle>messages.GroovyBundle</resource-bundle>

  <applicationListeners>
    <listener class="org.jetbrains.plugins.groovy.dsl.GroovyDslFileIndex$MyFileListener"
              topic="com.intellij.openapi.vfs.newvfs.BulkFileListener"/>
  </applicationListeners>

  <extensionPoints>
    <extensionPoint name="methodComparator" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.resolve.GrMethodComparator"/>
    <extensionPoint name="overloadResolver" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.resolve.api.GroovyOverloadResolver"/>
    <extensionPoint name="membersContributor" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.resolve.NonCodeMembersContributor"/>
    <extensionPoint name="importContributor" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.resolve.imports.GrImportContributor"/>
    <extensionPoint name="astTransformationSupport" dynamic="true" interface="org.jetbrains.plugins.groovy.transformations.AstTransformationSupport"/>
    <extensionPoint name="inlineASTTransformationSupport" dynamic="true" interface="org.jetbrains.plugins.groovy.transformations.inline.GroovyInlineASTTransformationSupport"/>
    <extensionPoint name="renameHelper" dynamic="true" interface="org.jetbrains.plugins.groovy.refactoring.rename.GrRenameHelper"/>
    <extensionPoint name="closureMissingMethodContributor" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.lang.resolve.ClosureMissingMethodContributor"/>
    <extensionPoint name="variableEnhancer" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrVariableEnhancer"/>
    <extensionPoint name="typeAugmenter" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.psi.dataFlow.types.TypeAugmenter"/>
    <extensionPoint name="referenceTypeEnhancer" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrReferenceTypeEnhancer"/>
    <extensionPoint name="typeConverter" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrTypeConverter"/>
    <extensionPoint name="expectedTypesContributor" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.lang.psi.expectedTypes.GroovyExpectedTypesContributor"/>

    <extensionPoint name="inspectionDisabler" beanClass="com.intellij.openapi.fileTypes.FileTypeExtensionPoint" dynamic="true">
      <with attribute="implementationClass" implements="org.jetbrains.plugins.groovy.codeInspection.FileTypeInspectionDisabler"/>
    </extensionPoint>



    <extensionPoint name="positionManagerDelegate" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.extensions.debugger.ScriptPositionManagerHelper"/>
    <extensionPoint name="scriptTypeDetector" dynamic="true" interface="org.jetbrains.plugins.groovy.extensions.GroovyScriptTypeDetector"/>

    <extensionPoint name="namedArgumentProvider" dynamic="true" interface="org.jetbrains.plugins.groovy.extensions.GroovyNamedArgumentProvider"/>
    <extensionPoint name="applicabilityProvider" dynamic="true" interface="org.jetbrains.plugins.groovy.extensions.GroovyApplicabilityProvider"/>
    <extensionPoint name="mapContentProvider" dynamic="true" interface="org.jetbrains.plugins.groovy.extensions.GroovyMapContentProvider"/>

    <extensionPoint name="unresolvedHighlightFilter" dynamic="true" interface="org.jetbrains.plugins.groovy.extensions.GroovyUnresolvedHighlightFilter"/>
    <extensionPoint name="unresolvedHighlightFileFilter" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.extensions.GroovyUnresolvedHighlightFileFilter"/>
    <extensionPoint name="configSlurperSupport" dynamic="true" interface="org.jetbrains.plugins.groovy.configSlurper.ConfigSlurperSupport"/>

    <extensionPoint name="typeCalculator" dynamic="true" beanClass="com.intellij.openapi.util.ClassExtensionPoint">
      <with attribute="implementationClass" implements="org.jetbrains.plugins.groovy.lang.typing.GrTypeCalculator"/>
    </extensionPoint>
    <extensionPoint name="callTypeCalculator" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.typing.GrCallTypeCalculator"/>

    <extensionPoint qualifiedName="com.intellij.newProjectWizard.groovy.buildSystem"
                    interface="org.jetbrains.plugins.groovy.config.wizard.BuildSystemGroovyNewProjectWizard" dynamic="true"/>

    <!--suppress PluginXmlValidity -->
    <extensionPoint name="classDescriptor" dynamic="true"
                    beanClass="org.jetbrains.plugins.groovy.extensions.GroovyClassDescriptor"/>
    <!--suppress PluginXmlValidity -->
    <extensionPoint name="methodDescriptor" dynamic="true"
                    beanClass="org.jetbrains.plugins.groovy.extensions.GroovyMethodDescriptorExtension"/>

    <!-- Groovy DSL extension points -->
    <extensionPoint name="psiEnhancerCategory" dynamic="false" interface="org.jetbrains.plugins.groovy.dsl.psi.PsiEnhancerCategory"/>
    <extensionPoint name="gdslTopLevelProvider" dynamic="false" interface="org.jetbrains.plugins.groovy.dsl.dsltop.GdslMembersProvider"/>

    <extensionPoint name="groovyFrameworkConfigNotification" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.annotator.GroovyFrameworkConfigNotification"/>
    <extensionPoint name="groovySourceFolderDetector" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.actions.GroovySourceFolderDetector"/>

    <extensionPoint name="closureCompleter" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.completion.ClosureCompleter"/>

    <extensionPoint name="methodMayBeStaticInspectionFilter" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.codeInspection.declaration.GrMethodMayBeStaticInspectionFilter"/>

    <extensionPoint name="customAnnotationChecker" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.annotator.checkers.CustomAnnotationChecker"/>

    <extensionPoint name="completionCustomizer" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.lang.completion.api.GroovyCompletionCustomizer"/>

    <extensionPoint name="convertToJava.customMethodInvocator" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.refactoring.convertToJava.invocators.CustomMethodInvocator"/>

    <extensionPoint name="signatureHintProcessor" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.SignatureHintProcessor"/>
    <extensionPoint name="gdslScriptProvider" dynamic="true" interface="org.jetbrains.plugins.groovy.dsl.GdslScriptProvider"/> <!--TODO-->
    <extensionPoint name="expectedPackageNameProvider" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.lang.resolve.ExpectedPackageNameProvider"/>
    <extensionPoint name="delegatesToProvider" dynamic="true"
                    interface="org.jetbrains.plugins.groovy.lang.resolve.delegatesTo.GrDelegatesToProvider"/>
    <extensionPoint name="elementFilter" dynamic="true" interface="org.jetbrains.plugins.groovy.lang.GroovyElementFilter"/>
    <extensionPoint name="inlayHintFilter" dynamic="true" interface="org.jetbrains.plugins.groovy.editor.GroovyInlayHintFilter"/>
  </extensionPoints>

  <extensions defaultExtensionNs="org.intellij.groovy">

    <groovyFrameworkConfigNotification order="last"
                                       implementation="org.jetbrains.plugins.groovy.config.DefaultGroovyFrameworkConfigNotification"/>

    <membersContributor implementation="org.jetbrains.plugins.groovy.ext.newify.NewifyMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.swingBuilder.SwingBuilderNonCodeMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.GrInterfaceDefaultMethodMemberContributor"/>

    <membersContributor implementation="org.jetbrains.plugins.groovy.builder.XmlMarkupBuilderNonCodeMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.builder.JsonBuilderContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.builder.JsonDelegateContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.builder.StreamingJsonBuilderContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.builder.StreamingJsonBuilderDelegateContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.dsl.GdslMemberContributor" order="last"/>

    <membersContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.contributor.SyntheticKeywordConstructorContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.contributor.PrePostParametersContributor"/>


    <closureMissingMethodContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.PluginXmlClosureMemberContributor"/>

    <astTransformationSupport id="groovyObjectTransformation" order="first"
                              implementation="org.jetbrains.plugins.groovy.transformations.impl.GroovyObjectTransformationSupport"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.AutoExternalizeContributor"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.impl.autoClone.AutoCloneTransformationSupport"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.InheritConstructorContributor"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.builder.strategy.DefaultBuilderStrategySupport"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.builder.strategy.SimpleBuilderStrategySupport"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.builder.strategy.ExternalBuilderStrategySupport"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.builder.strategy.InitializerBuilderStrategySupport"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.impl.BindableTransformationSupport"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.impl.VetoableTransformationSupport"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.autoimplement.AutoImplementTransformation"/>

    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.LoggingContributor"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.impl.CategoryTransformationSupport"/>
    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.impl.BaseScriptTransformationSupport"/>
    <astTransformationSupport id="autoFinalSupport" order="before defaultSupport"
                              implementation="org.jetbrains.plugins.groovy.transformations.impl.AutoFinalTransformationSupport"/>
    <astTransformationSupport id="defaultSupport"
                              implementation="org.jetbrains.plugins.groovy.transformations.impl.DefaultTransformationSupport"/>
    <astTransformationSupport id="recordSupport"
                              order="after defaultSupport"
                              implementation="org.jetbrains.plugins.groovy.transformations.impl.RecordTransformationSupport"/>
    <astTransformationSupport id="constructors"
                              order="after recordSupport"
                              implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.ConstructorAnnotationsProcessor"/>

    <renameHelper implementation="org.jetbrains.plugins.groovy.transformations.impl.DefaultRenameHelper"/>
    <astTransformationSupport order="after defaultSupport"
                              implementation="org.jetbrains.plugins.groovy.transformations.impl.FieldScriptTransformationSupport"/>
    <astTransformationSupport id="traitSupport" order="after defaultSupport, before delegateSupport"
                              implementation="org.jetbrains.plugins.groovy.transformations.impl.TraitTransformationSupport"/>
    <renameHelper implementation="org.jetbrains.plugins.groovy.transformations.impl.TraitRenameHelper"/>
    <astTransformationSupport id="delegateSupport" order="after defaultSupport"
                              implementation="org.jetbrains.plugins.groovy.transformations.impl.DelegateTransformationSupport"/>

    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.listenerList.ListenerListTransformationSupport"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.transformations.listenerList.ListenerListAnnotationChecker"/>

    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.singleton.SingletonTransformationSupport"/>

    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.immutable.ImmutableTransformationSupport"/>
    <namedArgumentProvider implementation="org.jetbrains.plugins.groovy.transformations.immutable.CopyWithNamedArgumentProvider"/>

    <astTransformationSupport implementation="org.jetbrains.plugins.groovy.transformations.impl.namedVariant.NamedVariantTransformationSupport"/>

    <inlineASTTransformationSupport implementation="org.jetbrains.plugins.groovy.ext.ginq.GinqAnnotationTransformationSupport"/>
    <inlineASTTransformationSupport implementation="org.jetbrains.plugins.groovy.ext.ginq.GinqMacroTransformationSupport"/>

    <methodDescriptor lightMethodKey="SwingBuilder_builder_method"
                      namedArgsProvider="org.jetbrains.plugins.groovy.swingBuilder.SwingBuilderNamedArgumentProvider"/>

    <mapContentProvider implementation="org.jetbrains.plugins.groovy.configSlurper.ConfigSlurperMapContentProvider"/>
    <referenceTypeEnhancer implementation="org.jetbrains.plugins.groovy.configSlurper.GroovyMapValueTypeEnhancer"/>

    <unresolvedHighlightFilter implementation="org.jetbrains.plugins.groovy.extensions.GroovyUnresolvedReferenceFilterByFile"/>

    <callTypeCalculator implementation="org.jetbrains.plugins.groovy.lang.typing.PredefinedReturnType"/>
    <callTypeCalculator implementation="org.jetbrains.plugins.groovy.lang.typing.WithTraitsTypeCalculator"/>
    <callTypeCalculator implementation="org.jetbrains.plugins.groovy.lang.typing.DgmCallTypeCalculator"/>
    <callTypeCalculator implementation="org.jetbrains.plugins.groovy.lang.typing.DgmIteratorCallTypeCalculator"/>
    <callTypeCalculator implementation="org.jetbrains.plugins.groovy.lang.typing.DgmNextPreviousCallTypeCalculator"/>
    <callTypeCalculator implementation="org.jetbrains.plugins.groovy.lang.typing.DgmIntdivCallTypeCalculator"/>
    <callTypeCalculator implementation="org.jetbrains.plugins.groovy.lang.typing.ClosureMethodsCallTypeCalculator"/>
    <callTypeCalculator implementation="org.jetbrains.plugins.groovy.lang.typing.ObjectClassTypeCalculator"/>
    <callTypeCalculator implementation="org.jetbrains.plugins.groovy.ext.ginq.types.GrNamedRecordCallTypeCalculator"/>

    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.GrClosureOwnerDelegateTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall"
                    implementationClass="org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.path.GrDescriptorReturnTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall"
                    implementationClass="org.jetbrains.plugins.groovy.transformations.inline.GroovyInlineTransformationTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression"
                    implementationClass="org.jetbrains.plugins.groovy.transformations.inline.GroovyInlineTransformationTypeCalculator"/>

    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrNewExpression"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultNewExpressionTypeCalculator" order="last"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.GrListOrMap" order="last"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultListOrMapTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.path.GrIndexProperty" order="last"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultIndexAccessTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultMethodCallTypeCalculator" order="last" id="defaultMethodCall"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrBuiltinTypeClassExpression" order="last"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultBuiltinTypeClassTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrSafeCastExpression" order="last"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultSafeCastTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrConditionalExpression" order="last"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultConditionalTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression" order="last"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultMethodReferenceTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.GrRangeExpression" order="last"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultRangeTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrUnaryExpression" order="last"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultUnaryExpressionTypeCalculator"/>
    <typeCalculator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrSwitchExpression" order="last"
                    implementationClass="org.jetbrains.plugins.groovy.lang.typing.DefaultSwitchExpressionTypeCalculator"/>

    <elementFilter implementation="org.jetbrains.plugins.groovy.transformations.inline.GroovyInlineTransformationElementFilter"/>

    <namedArgumentProvider implementation="org.jetbrains.plugins.groovy.lang.GroovySourceCodeNamedArgumentProvider" order="last"/>
    <namedArgumentProvider implementation="org.jetbrains.plugins.groovy.ext.newify.GroovyNewifyNamedArgumentProvider"/>
    <namedArgumentProvider implementation="org.jetbrains.plugins.groovy.lang.GroovyNewExprNamedArgumentProvider"/>
    <namedArgumentProvider implementation="org.jetbrains.plugins.groovy.lang.GroovyMethodReturnNamedArgumentProvider" order="last"/>
    <namedArgumentProvider implementation="org.jetbrains.plugins.groovy.transformations.impl.namedVariant.GroovyNamedVariantArgumentProvider"/>

    <applicabilityProvider implementation="org.jetbrains.plugins.groovy.ext.newify.NewifyConstructorApplicabilityProvider"/>

    <!-- GroovyDSL extensions -->
    <gdslTopLevelProvider implementation="org.jetbrains.plugins.groovy.dsl.dsltop.GroovyDslDefaultMembers"/>
    <gdslTopLevelProvider implementation="org.jetbrains.plugins.groovy.lang.resolve.GdkMethodDslProvider"/>
    <psiEnhancerCategory implementation="org.jetbrains.plugins.groovy.dsl.psi.PsiClassCategory"/>
    <psiEnhancerCategory implementation="org.jetbrains.plugins.groovy.dsl.psi.PsiElementCategory"/>
    <psiEnhancerCategory implementation="org.jetbrains.plugins.groovy.dsl.psi.PsiMethodCategory"/>
    <psiEnhancerCategory implementation="org.jetbrains.plugins.groovy.dsl.psi.PsiExpressionCategory"/>

    <variableEnhancer implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ClosureParamsEnhancer"/>
    <variableEnhancer implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ClosureParameterEnhancer"/>
    <variableEnhancer implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ClosureSamParameterEnhancer"/>

    <typeAugmenter implementation="org.jetbrains.plugins.groovy.intentions.style.inference.MethodParameterAugmenter"/>
    <typeAugmenter implementation="org.jetbrains.plugins.groovy.intentions.style.inference.ClosureParameterAugmenter"/>

    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.FromStringHintProcessor"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.SimpleTypeHintProcessor"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.MapEntryOrKeyValueHintProcessor"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.FromAbstractTypeMethodsHintProcessor"/>

    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.FirstParamHintProcessor"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.FirstParamHintProcessor$FirstGeneric"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.FirstParamHintProcessor$SecondGeneric"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.FirstParamHintProcessor$ThirdGeneric"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.FirstParamHintProcessor$Component"/>

    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.SecondParamHintProcessor"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.SecondParamHintProcessor$FirstGeneric"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.SecondParamHintProcessor$SecondGeneric"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.SecondParamHintProcessor$ThirdGeneric"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.SecondParamHintProcessor$Component"/>

    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ThirdParamHintProcessor"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ThirdParamHintProcessor$FirstGeneric"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ThirdParamHintProcessor$SecondGeneric"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ThirdParamHintProcessor$ThirdGeneric"/>
    <signatureHintProcessor implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ThirdParamHintProcessor$Component"/>


    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrBooleanTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrPrimitiveCastConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrGenericTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrClosureTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrListToArrayTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrClassConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrNullVoidConverter"/>

    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrCharConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrNumberConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrWildcardTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrStringConverter"/>

    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrEnumConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrContainerTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.sam.ClosureToSamConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrContainerConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrCollectionToArrayConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.typing.GrCollectionConstructorConverter"/>

    <expectedTypesContributor implementation="org.jetbrains.plugins.groovy.gpp.GppExpectedTypesContributor"/>
    <variableEnhancer implementation="org.jetbrains.plugins.groovy.gpp.GppClosureParameterTypeProvider"/>

    <closureCompleter implementation="org.jetbrains.plugins.groovy.lang.completion.GdslClosureCompleter"/>
    <closureCompleter implementation="org.jetbrains.plugins.groovy.lang.completion.EachWithIndexClosureCompleter"/>

    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.FieldAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.NewifyAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.GrabAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.GrAliasAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.AnnotationCollectorChecker" order="first"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.DelegatesToAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.DelegateAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.BuilderAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.BaseScriptAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.NamedParamAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.GeneratedConstructorAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.ImmutableOptionsAnnotationChecker"/>

    <convertToJava.customMethodInvocator
      implementation="org.jetbrains.plugins.groovy.refactoring.convertToJava.invocators.MapGetterSetterInvocator"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.TypeCheckedAnnotationChecker"/>
    <methodComparator implementation="org.jetbrains.plugins.groovy.lang.resolve.DGMGetAtMethodFilter" order="last"/>
    <methodComparator implementation="org.jetbrains.plugins.groovy.lang.resolve.GrDefaultMethodComparator" order="last"/>
    <overloadResolver implementation="org.jetbrains.plugins.groovy.lang.resolve.DGMGetAtOverloadResolver" order="last"/>
    <overloadResolver implementation="org.jetbrains.plugins.groovy.lang.resolve.impl.DistanceOverloadResolver" order="last"/>
    <expectedPackageNameProvider implementation="org.jetbrains.plugins.groovy.lang.resolve.DefaultExpectedPackageNameProvider"
                                 order="last"/>
    <delegatesToProvider implementation="org.jetbrains.plugins.groovy.lang.resolve.delegatesTo.DefaultDelegatesToProvider" id="default" order="last"/>
    <delegatesToProvider implementation="org.jetbrains.plugins.groovy.lang.resolve.delegatesTo.InferredDelegatesToProvider" order="last"/>
  </extensions>

  <extensions defaultExtensionNs="com.intellij.properties">
    <implicitPropertyUsageProvider implementation="org.jetbrains.plugins.groovy.dgm.DGMImplicitPropertyUsageProvider"/>
  </extensions>

  <extensions defaultExtensionNs="com.intellij">
    <fileType name="Groovy" language="Groovy" extensions="groovy;gy" hashBangs="groovy"
              implementationClass="org.jetbrains.plugins.groovy.GroovyFileType" fieldName="GROOVY_FILE_TYPE"/>
    <fileType name="gdsl" extensions="gdsl"
              implementationClass="org.jetbrains.plugins.groovy.GdslFileType" fieldName="INSTANCE"/>

    <highlightingPassFactory implementation="org.jetbrains.plugins.groovy.annotator.GrReferenceHighlighterFactory"/>
    <highlightingPassFactory implementation="org.jetbrains.plugins.groovy.highlighter.GroovyDeclarationHighlightingPassFactory"/>
    <highlightingPassFactory implementation="org.jetbrains.plugins.groovy.codeInspection.local.GroovyUnusedImportsPassFactory"/>
    <highlightingPassFactory implementation="org.jetbrains.plugins.groovy.transformations.inline.GroovyInlineTransformationHighlightingPassFactory"/>

    <registryKey key="groovy.document.based.formatting" defaultValue="false"
                 description="Enables Document based formatting instead of PSI based"/>
    <registryKey key="groovy.return.type.optimization" defaultValue="true"
                 description="Whether to skip substitutor computation if return type doesn't depend on it"/>
    <registryKey key="groovy.assert.element.kind.in.resolve" defaultValue="true"
                 description="Whether to throw error if the element is unexpected in resolve processor"/>
    <registryKey key="groovy.collect.method.calls.for.inference" defaultValue="false"
                 description="Allows to collect method usages for more precise type inference"/>
    <registryKey key="groovy.use.explicitly.typed.closure.in.inference" defaultValue="true"
                 description="Enable type inference with using info from explicitly typed closures"/>
    <registryKey key="groovy.flat.dfa" defaultValue="true"
                 description="Merges all control flows graphs in method"/>

    <additionalTextAttributes scheme="Default" file="colorSchemes/GroovyDefault.xml"/>
    <additionalTextAttributes scheme="Darcula" file="colorSchemes/GroovyDarcula.xml"/>

    <navbar implementation="org.jetbrains.plugins.groovy.navbar.GrNavBarModelExtension"/>

    <declarationRangeHandler key="org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod"
                             implementationClass="org.jetbrains.plugins.groovy.codeInsight.hint.GrMethodDeclarationRangeHandler"/>
    <declarationRangeHandler key="org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition"
                             implementationClass="org.jetbrains.plugins.groovy.codeInsight.hint.GrTypeDefinitionRangeHandler"/>
    <declarationRangeHandler key="org.jetbrains.plugins.groovy.lang.psi.api.statements.GrClassInitializer"
                             implementationClass="org.jetbrains.plugins.groovy.codeInsight.hint.GrClassInitializerDeclarationRangeHandler"/>


    <moduleBuilder builderClass="org.jetbrains.plugins.groovy.config.GroovyAwareModuleBuilder"/>

    <itemPresentationProvider forClass="org.jetbrains.plugins.groovy.lang.psi.impl.GroovyFileImpl"
                              implementationClass="org.jetbrains.plugins.groovy.findUsages.GrFileItemPresentationProvider"/>

    <testFramework implementation="org.jetbrains.plugins.groovy.testIntegration.GroovyTestFramework" order="first"/>

    <testCreator language="Groovy" implementationClass="com.intellij.testIntegration.JavaTestCreator"/>
    <testGenerator language="Groovy" implementationClass="org.jetbrains.plugins.groovy.testIntegration.GroovyTestGenerator"/>
    <runLineMarkerContributor language="Groovy" implementationClass="org.jetbrains.plugins.groovy.testIntegration.GroovyTestLineMarkerContributor"/>
    <runLineMarkerContributor language="Groovy" implementationClass="org.jetbrains.plugins.groovy.testIntegration.GroovyAppLineMarkerContributor"/>
    <constructorBodyGenerator language="Groovy"
                              implementationClass="org.jetbrains.plugins.groovy.annotator.intentions.dynamic.GrConstructorBodyGenerator"/>
    <editorNotificationProvider implementation="org.jetbrains.plugins.groovy.config.ConfigureGroovyLibraryNotificationProvider"/>
    <refactoring.introduceParameterMethodUsagesProcessor
      implementation="org.jetbrains.plugins.groovy.refactoring.introduce.parameter.java2groovy.GroovyIntroduceParameterMethodUsagesProcessor"/>
    <refactoring.changeSignatureUsageProcessor
      implementation="org.jetbrains.plugins.groovy.refactoring.changeSignature.GrChangeSignatureUsageProcessor" id="groovyProcessor"
      order="before javaProcessor"/>
    <changeSignature.usageProvider language="Groovy" implementationClass="org.jetbrains.plugins.groovy.refactoring.changeSignature.GrChangeSignatureUsageProvider"/>
    <safeDelete.importSearcher implementation="org.jetbrains.plugins.groovy.refactoring.safeDelete.GroovyImportSearcher"/>
    <refactoring.safeDelete.JavaSafeDeleteDelegate
      implementationClass="org.jetbrains.plugins.groovy.refactoring.safeDelete.JavaSafeDeleteDelegateForGroovy" language="Groovy"/>

    <encapsulateFields.Helper language="Groovy"
                              implementationClass="org.jetbrains.plugins.groovy.refactoring.encapsulateFields.GroovyEncapsulateFieldHelper"/>

    <constantExpressionEvaluator language="Groovy"
                                 implementationClass="org.jetbrains.plugins.groovy.lang.psi.util.GroovyConstantExpressionEvaluator"/>
    <annotationSupport language="Groovy"
                       implementationClass="org.jetbrains.plugins.groovy.lang.psi.impl.auxiliary.annotation.GroovyAnnotationSupport"/>

    <expressionConverter language="Groovy"
                         implementationClass="org.jetbrains.plugins.groovy.lang.psi.impl.GroovyExpressionConverter"/>

    <codeInsight.createFieldFromUsageHelper language="Groovy"
                                            implementationClass="org.jetbrains.plugins.groovy.annotator.intentions.GroovyCreateFieldFromUsageHelper"/>
    <codeInsight.typeInfo language="Groovy" implementationClass="org.jetbrains.plugins.groovy.codeInsight.hint.GroovyExpressionTypeProvider"/>
    <codeInsight.declarativeInlayProvider
      language="Groovy"
      implementationClass="org.jetbrains.plugins.groovy.codeInsight.hint.types.GroovyLocalVariableTypeHintsInlayProvider"
      isEnabledByDefault="true"
      group="TYPES_GROUP"
      providerId="groovy.local.variable.implicit.types"
      bundle="messages.GroovyBundle"
      nameKey="settings.inlay.groovy.local.variable.implicit.types.name"
      descriptionKey="settings.inlay.groovy.local.variable.implicit.types.description"/>
    <codeInsight.declarativeInlayProvider
      language="Groovy"
      implementationClass="org.jetbrains.plugins.groovy.codeInsight.hint.GroovyImplicitNullArgumentHintProvider"
      isEnabledByDefault="true"
      group="VALUES_GROUP"
      providerId="groovy.implicit.null.argument"
      bundle="messages.GroovyBundle"
      nameKey="settings.inlay.groovy.implicit.null.argument.provider.name"
      descriptionKey="settings.inlay.groovy.implicit.null.argument.provider.description"/>
    <codeInsight.parameterNameHints
        language="Groovy" implementationClass="org.jetbrains.plugins.groovy.codeInsight.hint.GroovyInlayParameterHintsProvider"
    />

    <fileType name="DGM"
              fileNames="org.codehaus.groovy.runtime.ExtensionModule"
              implementationClass="org.jetbrains.plugins.groovy.dgm.DGMFileType" fieldName="INSTANCE"/>

    <library.presentationProvider implementation="org.jetbrains.plugins.groovy.config.GroovyLibraryPresentationProvider"/>
    <library.type implementation="org.jetbrains.plugins.groovy.config.GroovyDownloadableLibraryType"/>

    <projectService serviceImplementation="org.jetbrains.plugins.groovy.gant.GantSettings"/>

    <spellchecker.support language="Groovy"
                          implementationClass="org.jetbrains.plugins.groovy.codeInspection.spellchecker.GroovySpellcheckingStrategy"/>
    <lang.inspectionSuppressor language="Groovy"
                               implementationClass="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionSuppressor"/>

    <colorSettingsPage implementation="org.jetbrains.plugins.groovy.highlighter.GroovyColorSettingsPage"/>
    <editorHighlighterProvider filetype="Groovy"
                               implementationClass="org.jetbrains.plugins.groovy.highlighter.GroovyEditorHighlighterProvider"/>
    <framework.type implementation="org.jetbrains.plugins.groovy.config.GroovyFrameworkType"/>
    <renameHandler implementation="org.jetbrains.plugins.groovy.refactoring.rename.PropertyRenameHandler"/>
    <renamePsiElementProcessor id="groovyFieldRenameProcessor"
                               implementation="org.jetbrains.plugins.groovy.refactoring.rename.RenameGrFieldProcessor"
                               order="first"/>
    <renamePsiElementProcessor id="groovyPropertyRenameProcessor"
                               implementation="org.jetbrains.plugins.groovy.refactoring.rename.RenameGroovyPropertyProcessor"
                               order="first"/>
    <renamePsiElementProcessor id="groovyLightElementRenamer"
                               implementation="org.jetbrains.plugins.groovy.refactoring.rename.GrLightElementRenamer"
                               order="first, after groovyPropertyRenameProcessor"/>
    <renamePsiElementProcessor implementation="org.jetbrains.plugins.groovy.refactoring.rename.RenameGrReflectedMethodProcessor"
                               order="first"/>
    <renamePsiElementProcessor implementation="org.jetbrains.plugins.groovy.refactoring.rename.RenameAliasImportedClassProcessor"
                               order="first"/>
    <renamePsiElementProcessor implementation="org.jetbrains.plugins.groovy.refactoring.rename.RenameAliasImportedMethodProcessor"
                               order="first"/>
    <renamePsiElementProcessor implementation="org.jetbrains.plugins.groovy.refactoring.rename.RenameGroovyScriptProcessor"/>
    <renamePsiElementProcessor implementation="org.jetbrains.plugins.groovy.transformations.impl.synch.SynchronizedRenameFieldProcessor"
                               order="first, before groovyFieldRenameProcessor"/>
    <renamePsiElementProcessor id="groovyMacroElementRenamer"
                               implementation="org.jetbrains.plugins.groovy.refactoring.rename.GrInlineTransformationElementRenamer"
                               order="last"/>

    <automaticRenamerFactory implementation="org.jetbrains.plugins.groovy.refactoring.rename.GroovyAutomaticOverloadsRenamerFactory"/>

    <rename.inplace.resolveSnapshotProvider language="Groovy"
                                            implementationClass="org.jetbrains.plugins.groovy.refactoring.rename.inplace.GroovyResolveSnapshotProvider"/>

    <renameHandler implementation="org.jetbrains.plugins.groovy.refactoring.rename.inplace.GrVariableInplaceRenameHandler"/>
    <renameHandler implementation="org.jetbrains.plugins.groovy.refactoring.rename.inplace.GrMethodInplaceRenameHandler"/>

    <nameSuggestionProvider implementation="org.jetbrains.plugins.groovy.refactoring.GroovyNameSuggestionProvider"/>

    <statementUpDownMover implementation="org.jetbrains.plugins.groovy.editor.actions.GroovyStatementMover"/>
    <joinLinesHandler implementation="org.jetbrains.plugins.groovy.editor.actions.joinLines.GrVariableJoinLinesHandler"/>
    <joinLinesHandler implementation="org.jetbrains.plugins.groovy.editor.actions.joinLines.GrJoinBlockStatementHandler"/>
    <joinLinesHandler implementation="org.jetbrains.plugins.groovy.editor.actions.joinLines.GrJoinControlStatementHandler"/>
    <joinLinesHandler implementation="org.jetbrains.plugins.groovy.editor.actions.joinLines.GrJoinStatementsHandler"/>

    <applicationService serviceImplementation="org.jetbrains.plugins.groovy.settings.GroovyApplicationSettings"/>
    <applicationService serviceInterface="org.jetbrains.plugins.groovy.dsl.DslErrorReporter"
                        serviceImplementation="org.jetbrains.plugins.groovy.dsl.DslErrorReporterImpl"/>

    <!-- Groovy language -->
    <lang.syntaxHighlighterFactory language="Groovy"
                                   implementationClass="org.jetbrains.plugins.groovy.highlighter.GroovySyntaxHighlighterFactory"/>

    <annotator language="Groovy" implementationClass="org.jetbrains.plugins.groovy.highlighter.GroovyKeywordAnnotator"/>
    <annotator language="Groovy" implementationClass="org.jetbrains.plugins.groovy.annotator.GrAnnotatorImpl"/>
    <annotator language="Groovy" implementationClass="org.jetbrains.plugins.groovy.annotator.GroovyVersionAnnotator"/>
    <annotator language="Groovy" implementationClass="org.jetbrains.plugins.groovy.dsl.GroovyDslAnnotator"/>
    <annotator language="Groovy" implementationClass="org.jetbrains.plugins.groovy.transformations.impl.synch.SynchronizedTransformationAnnotator"/>

    <lang.psiStructureViewFactory language="Groovy"
                                  implementationClass="org.jetbrains.plugins.groovy.structure.GroovyStructureViewFactory"/>
    <lang.parserDefinition language="Groovy" implementationClass="org.jetbrains.plugins.groovy.lang.parser.GroovyParserDefinition"/>
    <lang.commenter language="Groovy" implementationClass="org.jetbrains.plugins.groovy.highlighter.GroovyCommenter"/>
    <lang.foldingBuilder language="Groovy" implementationClass="org.jetbrains.plugins.groovy.lang.folding.GroovyFoldingBuilder"/>
    <lang.formatter language="Groovy" implementationClass="org.jetbrains.plugins.groovy.formatter.GroovyFormattingModelBuilder"/>
    <lang.whiteSpaceFormattingStrategy language="Groovy"
                                       implementationClass="org.jetbrains.plugins.groovy.formatter.GroovyWhiteSpaceFormattingStrategy"/>
    <inspection.basicVisitor class="org.jetbrains.plugins.groovy.lang.psi.GroovyElementVisitor"/>

    <focusModeProvider language="Groovy" implementationClass="org.jetbrains.plugins.groovy.lang.GrFocusModeProvider" />
    <postFormatProcessor implementation="org.jetbrains.plugins.groovy.formatter.GroovyBracePostFormatProcessor"/>

    <enterHandlerDelegate implementation="org.jetbrains.plugins.groovy.editor.actions.GroovyEnterHandler"
                          order="before EnterBetweenBracesHandler"/>
    <typedHandler implementation="org.jetbrains.plugins.groovy.editor.actions.GStringTypedActionHandler"/>
    <backspaceHandlerDelegate implementation="org.jetbrains.plugins.groovy.editor.actions.GStringBackspaceHandlerDelegate"/>
    <backspaceHandlerDelegate implementation="org.jetbrains.plugins.groovy.editor.actions.GroovyTripleQuoteBackspaceHandlerDelegate"/>
    <typedHandler implementation="org.jetbrains.plugins.groovy.editor.actions.GroovyStringBackslashHandler"/>

    <typedHandler implementation="org.jetbrains.plugins.groovy.editor.actions.GroovyTypedHandler"/>
    <backspaceHandlerDelegate implementation="org.jetbrains.plugins.groovy.editor.actions.GroovyBackspaceHandler"/>

    <codeInsight.template.postfixTemplateProvider language="Groovy" implementationClass="org.jetbrains.plugins.groovy.codeInsight.template.postfix.GroovyPostfixTemplateProvider"/>

    <liveTemplateContext contextId="GROOVY" implementation="org.jetbrains.plugins.groovy.template.GroovyTemplateContextType$Generic"/>
    <liveTemplateContext contextId="GROOVY_EXPRESSION" baseContextId="GROOVY" implementation="org.jetbrains.plugins.groovy.template.GroovyTemplateContextType$Expression"/>
    <liveTemplateContext contextId="GROOVY_STATEMENT" baseContextId="GROOVY" implementation="org.jetbrains.plugins.groovy.template.GroovyTemplateContextType$Statement"/>
    <liveTemplateContext contextId="GROOVY_DECLARATION" baseContextId="GROOVY" implementation="org.jetbrains.plugins.groovy.template.GroovyTemplateContextType$Declaration"/>

    <defaultLiveTemplates file="liveTemplates/Groovy.xml"/>

    <liveTemplateOptionalProcessor implementation="org.jetbrains.plugins.groovy.template.GroovyShortenFQNamesProcessor"/>
    <variableTypeCalculator implementation="org.jetbrains.plugins.groovy.template.GroovyVariableTypeCalculator"/>

    <gotoSymbolContributor implementation="org.jetbrains.plugins.groovy.gotoclass.GroovyGoToSymbolContributor"/>
    <lang.refactoringSupport language="Groovy"
                             implementationClass="org.jetbrains.plugins.groovy.refactoring.GroovyRefactoringSupportProvider"/>
    <lang.surroundDescriptor language="Groovy"
                             implementationClass="org.jetbrains.plugins.groovy.lang.surroundWith.GroovySurroundDescriptor"/>
    <lang.findUsagesProvider language="Groovy" implementationClass="org.jetbrains.plugins.groovy.findUsages.GroovyFindUsagesProvider"/>
    <importFilteringRule implementation="org.jetbrains.plugins.groovy.findUsages.GrImportFilteringRule"/>

    <readWriteAccessDetector implementation="org.jetbrains.plugins.groovy.findUsages.GroovyReadWriteAccessDetector"
                             id="defaultGroovy" order="before java"/>
    <findUsagesHandlerFactory implementation="org.jetbrains.plugins.groovy.findUsages.GroovyFieldFindUsagesHandlerFactory"/>
    <highlightUsagesHandlerFactory implementation="org.jetbrains.plugins.groovy.findUsages.GrHighlightHandlerFactory"/>
    <lang.braceMatcher language="Groovy" implementationClass="org.jetbrains.plugins.groovy.highlighter.GroovyBraceMatcher"/>
    <lang.importOptimizer language="Groovy" implementationClass="org.jetbrains.plugins.groovy.editor.GroovyImportOptimizer"/>
    <lang.documentationProvider language="Groovy"
                                implementationClass="org.jetbrains.plugins.groovy.lang.documentation.GroovyDocumentationProvider"/>
    <lang.smartEnterProcessor language="Groovy"
                              implementationClass="org.jetbrains.plugins.groovy.lang.completion.smartEnter.GroovySmartEnterProcessor"/>
    <codeInsight.overrideMethod language="Groovy"
                                implementationClass="org.jetbrains.plugins.groovy.overrideImplement.GroovyOverrideMethodsHandler"/>
    <codeInsight.implementMethod language="Groovy"
                                 implementationClass="org.jetbrains.plugins.groovy.overrideImplement.GroovyImplementMethodsHandler"/>

    <methodImplementor implementation="org.jetbrains.plugins.groovy.overrideImplement.GroovyMethodImplementor"/>
    <methodImplementor implementation="org.jetbrains.plugins.groovy.overrideImplement.TraitMethodImplementor"/>
    <codeInsight.parameterInfo language="Groovy"
                               implementationClass="org.jetbrains.plugins.groovy.lang.parameterInfo.GroovyParameterInfoHandler"/>
    <codeInsight.parameterInfo language="Groovy"
                               implementationClass="org.jetbrains.plugins.groovy.lang.parameterInfo.GroovyAnnotationAttributeInfoHandler"/>
    <codeInsight.parameterInfo language="Groovy"
                               implementationClass="org.jetbrains.plugins.groovy.lang.parameterInfo.GroovyTypeParameterInfoHandler"/>
    <refactoring.inlineHandler language="Groovy" implementationClass="org.jetbrains.plugins.groovy.refactoring.inline.GroovyInlineHandler"/>
    <inlineActionHandler implementation="org.jetbrains.plugins.groovy.refactoring.inline.GroovyInlineLocalHandler"/>

    <refactoring.moveClassHandler implementation="org.jetbrains.plugins.groovy.refactoring.move.MoveGroovyClassHandler"/>
    <refactoring.moveInnerHandler language="Groovy"
                                  implementationClass="org.jetbrains.plugins.groovy.refactoring.move.MoveGroovyInnerHandler"/>
    <refactoring.moveClassToInnerHandler implementation="org.jetbrains.plugins.groovy.refactoring.move.GroovyMoveClassToInnerHandler"/>
    <refactoring.moveHandler implementation="org.jetbrains.plugins.groovy.refactoring.move.MoveGroovyStaticInnerClassHandler" id="groovy"/>
    <moveFileHandler implementation="org.jetbrains.plugins.groovy.refactoring.move.MoveGroovyFileHandler"/>
    <refactoring.moveMemberHandler language="Groovy"
                                   implementationClass="org.jetbrains.plugins.groovy.refactoring.move.MoveGroovyMemberHandler"/>

    <refactoring.helper implementation="org.jetbrains.plugins.groovy.refactoring.GroovyImportOptimizerRefactoringHelper"/>
    <codeInsight.lineMarkerProvider language="Groovy"
                                    implementationClass="org.jetbrains.plugins.groovy.codeInsight.GroovyLineMarkerProvider"/>
    <codeInsight.lineMarkerProvider language="Groovy"
                                    implementationClass="com.intellij.codeInsight.ExternalAnnotationLineMarkerProvider"/>
    <codeInsight.lineMarkerProvider language="Groovy"
                                    implementationClass="org.jetbrains.plugins.groovy.codeInsight.GrRecursiveCallLineMarkerProvider"/>
    <codeInsight.gotoSuper language="Groovy"
                           implementationClass="org.jetbrains.plugins.groovy.codeInsight.navigation.actions.GroovyGotoSuperHandler"/>
    <lookup.charFilter implementation="org.jetbrains.plugins.groovy.lang.completion.GroovyReferenceCharFilter"/>
    <completion.plainTextSymbol language="Groovy" implementationClass="com.intellij.codeInsight.completion.JvmPlainTextSymbolCompletionContributor"/>
    <completion.contributor language="Groovy" implementationClass="org.jetbrains.plugins.groovy.lang.completion.GroovyNoVariantsDelegator"
                            id="groovyBasic2ClassName" order="first, after liveTemplates"/>
    <completion.contributor language="Groovy" implementationClass="org.jetbrains.plugins.groovy.lang.completion.GroovyCompletionContributor"
                            id="groovyBasic" order="before javaClassName"/>

    <completion.contributor language="Groovy"
                            implementationClass="org.jetbrains.plugins.groovy.lang.completion.GroovySmartCompletionContributor"/>
    <completion.contributor language="Groovy" implementationClass="org.jetbrains.plugins.groovy.lang.completion.GrMethodMergingContributor"
                            id="grMethodMerger" order="before methodMerger"/>

    <completion.contributor language="Properties" implementationClass="org.jetbrains.plugins.groovy.dgm.DGMCompletionContributor"/>

    <completion.confidence language="Groovy" implementationClass="org.jetbrains.plugins.groovy.lang.completion.GroovyCompletionConfidence"
                           id="groovyAdvanced"/>
    <completion.confidence language="Groovy" implementationClass="com.intellij.codeInsight.completion.SkipAutopopupInComments"
                           id="groovyComments"/>
    <cantBeStatic implementation="org.jetbrains.plugins.groovy.codeInspection.declaration.GrCategoryMethodsCantBeStaticExtension"/>

    <psi.referenceContributor language="Properties" implementation="org.jetbrains.plugins.groovy.dgm.DGMReferenceContributor"/>

    <psi.referenceContributor language="Groovy"
                              implementation="org.jetbrains.plugins.groovy.lang.resolve.GroovyMethodArgumentReferenceContributor"/>

    <weigher key="completion" implementationClass="org.jetbrains.plugins.groovy.lang.completion.weighers.GrWithWeigher"
             id="groovyWithWeigher" order="after prefix, after stats"/>
    <weigher key="completion" implementationClass="org.jetbrains.plugins.groovy.lang.completion.weighers.GrKindWeigher"
             id="groovyKindWeigher" order="after groovyWithWeigher, before explicitProximity"/>

    <weigher key="proximity" implementationClass="org.jetbrains.plugins.groovy.lang.completion.weighers.GrReferenceListWeigher"
             id="groovyReferenceListWeigher" order="before openedInEditor"/>

    <debuggerClassFilterProvider implementation="org.jetbrains.plugins.groovy.debugger.GroovyDebuggerClassFilterProvider"/>

    <useScopeEnlarger implementation="org.jetbrains.plugins.groovy.lang.psi.impl.search.GrPrivateFieldScopeEnlarger"/>

    <debuggerEditorTextProvider language="Groovy" implementationClass="org.jetbrains.plugins.groovy.debugger.GroovyEditorTextProvider"/>

    <xdebugger.settings implementation="org.jetbrains.plugins.groovy.debugger.GroovyDebuggerSettings"/>
    <langCodeStyleSettingsProvider implementation="org.jetbrains.plugins.groovy.codeStyle.GroovyLanguageCodeStyleSettingsProvider"/>
    <codeStyleSettingsProvider implementation="org.jetbrains.plugins.groovy.codeStyle.GroovyGenerationSettingsProvider"/>
    <lang.lineWrapStrategy language="Groovy" implementationClass="org.jetbrains.plugins.groovy.formatter.GrLineWrapPositionStrategy"/>



    <typeHierarchyProvider language="Groovy" implementationClass="org.jetbrains.plugins.groovy.hierarchy.type.GroovyTypeHierarchyProvider"/>
    <callHierarchyProvider language="Groovy" implementationClass="org.jetbrains.plugins.groovy.hierarchy.call.GrCallHierarchyProvider"/>

    <lang.unwrapDescriptor language="Groovy" implementationClass="org.jetbrains.plugins.groovy.unwrap.GroovyUnwrapDescriptor"/>

    <lang.elementManipulator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrLiteral"
                             implementationClass="org.jetbrains.plugins.groovy.lang.resolve.GroovyStringLiteralManipulator"/>
    <lang.elementManipulator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentLabel"
                             implementationClass="org.jetbrains.plugins.groovy.lang.psi.impl.statements.arguments.GrArgumentLabelManipulator"/>
    <lang.elementManipulator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrStringContent"
                             implementationClass="org.jetbrains.plugins.groovy.lang.resolve.GroovyStringLiteralManipulator"/>
    <lang.elementManipulator forClass="org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression"
                             implementationClass="org.jetbrains.plugins.groovy.lang.resolve.GroovyMacroManipulator"/>


    <directClassInheritorsSearch implementation="org.jetbrains.plugins.groovy.lang.psi.impl.GroovyDirectInheritorsSearcher"/>

    <typeDeclarationProvider implementation="org.jetbrains.plugins.groovy.editor.GroovyTypeDeclarationProvider" order="first"/>

    <lang.sliceProvider language="Groovy" implementationClass="org.jetbrains.plugins.groovy.slicer.GroovySliceProvider"/>

    <!--Run/debug-->
    <configurationType implementation="org.jetbrains.plugins.groovy.runner.GroovyScriptRunConfigurationType"/>
    <runConfigurationProducer implementation="org.jetbrains.plugins.groovy.runner.ScriptRunConfigurationProducer"/>

    <quoteHandler fileType="Groovy" className="org.jetbrains.plugins.groovy.editor.GroovyQuoteHandler"/>

    <compileServer.plugin classpath="groovy-jps.jar;groovy-constants-rt.jar"/>
    <compiler.buildTargetScopeProvider implementation="org.jetbrains.plugins.groovy.compiler.GroovyTargetScopeProvider"/>

    <indexPatternBuilder implementation="org.jetbrains.plugins.groovy.util.GroovyIndexPatternBuilder"/>
    <todoIndexer filetype="Groovy" implementationClass="org.jetbrains.plugins.groovy.highlighter.GroovyTodoIndexer"/>

    <basicWordSelectionFilter implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyWordSelectionFilter"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyLiteralSelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyMembersWithDocSelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyBlockStatementsSelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyTypeDefinitionBodySelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyTypeCastSelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyDocParamsSelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyArgListSelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyGStringSelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyParameterListSelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyElseSelectioner"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyWordSelectionHandler"/>
    <extendWordSelectionHandler implementation="org.jetbrains.plugins.groovy.editor.selection.GroovyStatementSelectioner"/>


    <methodReferencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.PropertyMethodReferenceSearchExecutor"/>
    <methodReferencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.MethodLateBoundReferencesSearcher"/>
    <methodReferencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.GroovyConstructorUsagesSearcher"/>
    <methodReferencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.GroovyReflectedMethodReferenceSearcher"/>
    <methodReferencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.GrLiteralMethodSearcher"/>
    <methodReferencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.GrNewMethodsReferencesSearcher"/>
    <annotatedElementsSearch implementation="org.jetbrains.plugins.groovy.findUsages.AnnotatedMembersSearcher"/>
    <superMethodsSearch implementation="org.jetbrains.plugins.groovy.findUsages.GDKSuperMethodSearcher"/>
    <definitionsScopedSearch implementation="org.jetbrains.plugins.groovy.findUsages.GroovyImplementationSearch"/>

    <targetElementEvaluator language="Groovy"
                            implementationClass="org.jetbrains.plugins.groovy.lang.psi.impl.GroovyTargetElementEvaluator"/>

    <projectConfigurable instance="org.jetbrains.plugins.groovy.compiler.GroovyCompilerConfigurable" id="Groovy compiler"
                         key="configurable.GroovyCompilerConfigurable.display.name"
                         parentId="project.propCompiler"/>
    <java.compiler implementation="org.jetbrains.plugins.groovy.compiler.GreclipseIdeaCompiler"/>
    <projectService serviceImplementation="org.jetbrains.plugins.groovy.compiler.GreclipseIdeaCompilerSettings"/>
    <buildProcess.parametersProvider implementation="org.jetbrains.plugins.groovy.compiler.GrBuildProcessParametersProvider"/>

    <stubElementTypeHolder class="org.jetbrains.plugins.groovy.lang.parser.GroovyStubElementTypes" externalIdPrefix="gr."/>
    <stubElementTypeHolder class="org.jetbrains.plugins.groovy.lang.parser.GroovyEmptyStubElementTypes" externalIdPrefix="Groovy"/>
    <!--Stubs index-->
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrFullClassNameStringIndex"/>
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrFullScriptNameStringIndex"/>
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrFieldNameIndex"/>
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrMethodNameIndex"/>
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrAnnotationMethodNameIndex"/>
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrAnnotatedMemberIndex"/>
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrScriptClassNameIndex"/>
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrDirectInheritorsIndex"/>
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrAnonymousClassIndex"/>

    <referencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.GrConstructorReferencesSearcher"/>
    <referencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.GrInlineTransformationReferencesSearcher"/>
    <referencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.GrAliasedImportedElementSearcher"/>
    <referencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.AccessorReferencesSearcher"/>
    <referencesSearch implementation="org.jetbrains.plugins.groovy.findUsages.GroovyTraitFieldSearcher"/>

    <fileIconProvider implementation="org.jetbrains.plugins.groovy.GroovyFileIconProvider"/>

    <projectService serviceInterface="org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory"
                    serviceImplementation="org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiElementFactoryImpl"/>
    <projectService serviceImplementation="org.jetbrains.plugins.groovy.compiler.GroovyCompilerConfiguration"/>

    <psi.referenceContributor language="Groovy"
                              implementation="org.jetbrains.plugins.groovy.lang.resolve.providers.GroovyReferenceContributor"/>
    <psi.referenceContributor language="Groovy"
                              implementation="org.jetbrains.plugins.groovy.transformations.impl.synch.SynchronizedReferenceContributor"/>

    <resolveScopeProvider implementation="org.jetbrains.plugins.groovy.lang.resolve.GroovyResolveScopeProvider"/>
    <resolveScopeEnlarger implementation="org.jetbrains.plugins.groovy.bundled.BundledGroovyResolveScopeProvider"/>

    <java.elementFinder implementation="org.jetbrains.plugins.groovy.lang.psi.impl.javaView.GroovyClassFinder"/>
    <java.elementFinder implementation="org.jetbrains.plugins.groovy.lang.psi.impl.javaView.GroovyLightInnerClassFinder"/>
    <java.elementFinder implementation="org.jetbrains.plugins.groovy.gant.GantClassFinder"/>
    <java.elementFinder implementation="org.jetbrains.plugins.groovy.bundled.BundledGroovyClassFinder"/>
    <java.shortNamesCache implementation="org.jetbrains.plugins.groovy.lang.stubs.GroovyShortNamesCache"/>

    <projectService
        serviceImplementation="org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager"/>
    <projectService serviceInterface="org.jetbrains.plugins.groovy.lang.psi.impl.GroovyCodeStyleManager"
                    serviceImplementation="org.jetbrains.plugins.groovy.codeStyle.GroovyCodeStyleManagerImpl"/>
    <projectService serviceInterface="org.jetbrains.plugins.groovy.lang.psi.impl.GroovyCodeStyleSettingsFacade"
                    serviceImplementation="org.jetbrains.plugins.groovy.codeStyle.GroovyCodeStyleSettingsFacadeImpl"/>
    <projectService serviceInterface="org.jetbrains.plugins.groovy.transformations.macro.GroovyMacroRegistryService"
                    serviceImplementation="org.jetbrains.plugins.groovy.dgm.GroovyMacroRegistryServiceImpl" />

    <problemFileHighlightFilter implementation="org.jetbrains.plugins.groovy.GroovyProblemFileHighlightFilter"/>

    <renameInputValidator implementation="org.jetbrains.plugins.groovy.GroovyRenameInputValidator"/>
    <lang.namesValidator implementationClass="org.jetbrains.plugins.groovy.lang.GroovyNamesValidator" language="Groovy"/>

    <patterns.patternClass className="org.jetbrains.plugins.groovy.lang.psi.patterns.GroovyPatterns" alias="groovy"/>

    <stacktrace.fold substring="at org.codehaus.groovy."/>
    <stacktrace.fold substring="at groovy."/>
    <stacktrace.fold substring="at org.codehaus.groovy.runtime.DefaultGroovyMethods." negate="true"/>
    <stacktrace.fold substring="at org.codehaus.groovy.vmplugin.v5.PluginDefaultGroovyMethods." negate="true"/>
    <stacktrace.fold substring="at org.codehaus.groovy.runtime.DefaultGroovyMethodsSupport." negate="true"/>

    <projectStructureDetector implementation="org.jetbrains.plugins.groovy.GroovySourceRootDetector" id="groovyDetector"/>

    <generation.topLevelFactory language="Groovy" implementationClass="org.jetbrains.plugins.groovy.lang.psi.impl.GroovyFactoryProvider"/>

    <editorNotificationProvider implementation="org.jetbrains.plugins.groovy.compiler.GroovyStubNotificationProvider"/>

    <treeCopyHandler implementation="org.jetbrains.plugins.groovy.lang.GroovyChangeUtilSupport"/>
    <treeGenerator implementation="org.jetbrains.plugins.groovy.lang.psi.impl.source.impl.GroovyTreeGenerator" order="first"/>

    <copyPastePreProcessor implementation="org.jetbrains.plugins.groovy.editor.GroovyLiteralCopyPasteProcessor"/>
    <copyPastePostProcessor implementation="org.jetbrains.plugins.groovy.editor.GroovyReferenceCopyPasteProcessor"/>

    <regExpLanguageHost forClass="org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.literals.GrLiteralImpl"
                        implementationClass="org.jetbrains.plugins.groovy.regexp.GroovyRegExpHost"/>

    <lang.jvm.actions.jvmElementActionsFactory implementation="org.jetbrains.plugins.groovy.annotator.intentions.elements.GroovyElementActionsFactory"/>
    <localInspection language="Groovy" key="inspection.display.name.unused.declaration"
                     groupPath="Groovy"
                     groupKey="inspection.redundancy" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.GroovyUnusedDeclarationInspection" unfair="true"/>

    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.second.unsafe.call" groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.secondUnsafeCall.SecondUnsafeCallInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnusedAssignment"
                     key="inspection.display.name.unused.assignment" groupKey="inspection.data.flow" enabledByDefault="true"
                     editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.unusedDef.UnusedDefInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnusedIncOrDec"
                     key="inspection.display.name.unused.inc.dec" groupKey="inspection.data.flow" enabledByDefault="true"
                     editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrUnusedIncDecInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyVariableNotAssigned"
                     key="inspection.display.name.unassigned.access" groupKey="inspection.data.flow" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.unassignedVariable.UnassignedVariableAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyMissingReturnStatement"
                     key="inspection.display.name.no.return" groupKey="inspection.data.flow" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.noReturnMethod.MissingReturnInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.type.customizer"
                     groupKey="inspection.other" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.resources.TypeCustomizerInspection"/>

    <localInspection language="Groovy"
                     groupPath="Groovy"
                     key="inspection.display.name.assignability.check"
                     groupKey="inspection.assignments"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignabilityCheckInspection"/>

    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.result.of.assignment.used"
                     groupKey="inspection.assignments"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyResultOfAssignmentUsedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.assignment.can.be.operator.assignment"
                     groupKey="inspection.assignments"
                     enabledByDefault="true" level="INFORMATION"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignmentCanBeOperatorAssignmentInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.assignment.to.for.loop.parameter"
                     groupKey="inspection.assignments"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignmentToForLoopParameterInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.assignment.to.method.parameter"
                     groupKey="inspection.assignments"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignmentToMethodParameterInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.nested.assignment"
                     groupKey="inspection.assignments"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyNestedAssignmentInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.silly.assignment"
                     groupKey="inspection.assignments" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovySillyAssignmentInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.unchecked.assignment.of.member.of.raw.type"
                     groupKey="inspection.assignments" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyUncheckedAssignmentOfMemberOfRawTypeInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.continue.or.break.from.finally.block"
                     groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyContinueOrBreakFromFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.method.may.be.static"
                     groupKey="inspection.other" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.declaration.GrMethodMayBeStaticInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.return.from.finally.block" groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyReturnFromFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.throw.from.finally.block" groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyThrowFromFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.empty.catch.block"
                     groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyEmptyCatchBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.empty.finally.block"
                     groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyEmptyFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.empty.try.block"
                     groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyEmptyTryBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.unused.catch.parameter"
                     groupKey="inspection.error.handling"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyUnusedCatchParameterInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.break"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyBreakInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.continue"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyContinueInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.unreachable.statement"
                     groupKey="inspection.validity"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.validity.GroovyUnreachableStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.loop.statement.that.doesnt.loop" groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyLoopStatementThatDoesntLoopInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.conditional.with.identical.branches"
                     groupKey="inspection.control.flow" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConditionalWithIdenticalBranchesInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.conditional.can.be.elvis" groupKey="inspection.control.flow"
                     enabledByDefault="true" level="INFORMATION"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConditionalCanBeElvisInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.conditional.can.be.conditional.call"
                     groupKey="inspection.control.flow" enabledByDefault="true" level="INFORMATION"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConditionalCanBeConditionalCallInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.if.statement.with.identical.branches"
                     groupKey="inspection.control.flow" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyIfStatementWithIdenticalBranchesInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.if.statement.with.too.many.branches"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyIfStatementWithTooManyBranchesInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.fallthrough"
                     groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyFallthroughInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.unnecessary.continue" groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyUnnecessaryContinueInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.unnecessary.return"
                     groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyUnnecessaryReturnInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.final.variable.access"
                     groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.finalVar.GrFinalVariableAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.switch.statement.with.no.default"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovySwitchStatementWithNoDefaultInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.return.from.closure.can.be.implicit"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyReturnFromClosureCanBeImplicitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.trivial.conditional" groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyTrivialConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.constant.conditional" groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConstantConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.constant.if.statement"
                     groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConstantIfStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.trivial.if"
                     groupKey="inspection.control.flow" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyTrivialIfInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.java.style.properties.invocation"
                     groupKey="inspection.style" enabledByDefault="true" level="INFORMATION"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.JavaStylePropertiesInvocationInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     key="inspection.display.name.unnecessary.def.modifier" cleanupTool="true" enabledByDefault="true"
                     editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessaryDefModifierInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     key="inspection.display.name.unnecessary.final.modifier" cleanupTool="true" enabledByDefault="true"
                     editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessaryFinalModifierInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     key="inspection.display.name.unnecessary.sealed.modifier" cleanupTool="true" enabledByDefault="true"
                     editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessarySealedModifierInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     key="inspection.display.name.unnecessary.non.sealed.modifier" cleanupTool="true" enabledByDefault="true"
                     editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessaryNonSealedModifierInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     key="inspection.display.name.unnecessary.public.modifier" cleanupTool="true" enabledByDefault="true"
                     editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessaryPublicModifierInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     key="inspection.display.name.unnecessary.semicolon" cleanupTool="true" enabledByDefault="true"
                     editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessarySemicolonInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     key="inspection.display.name.unnecessary.alias" cleanupTool="true" enabledByDefault="true" level="WEAK WARNING"
                     editorAttributes="NOT_USED_ELEMENT_ATTRIBUTES"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessaryAliasInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.change.to.operator"
                     groupKey="inspection.style" enabledByDefault="true" level="WEAK WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.changeToOperator.ChangeToOperatorInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.change.to.method"
                     groupKey="inspection.style" enabledByDefault="true" level="INFORMATION"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.changeToMethod.ChangeToMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.access.to.static.field.locked.on.instance"
                     groupKey="inspection.threading" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyAccessToStaticFieldLockedOnInstanceInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.double.checked.locking"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyDoubleCheckedLockingInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.unconditional.wait"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyUnconditionalWaitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.public.field.accessed.in.synchronized.context" groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyPublicFieldAccessedInSynchronizedContextInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.busy.wait" groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyBusyWaitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.empty.sync.block"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyEmptySyncBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.synchronization.on.this"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizationOnThisInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.synchronized.method"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizedMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.nested.synchronized.statement"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyNestedSynchronizedStatementInspection"/>
    <!--suppress PluginXmlCapitalization -->
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.thread.stop.suspend.resume"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyThreadStopSuspendResumeInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.system.run.finalizers.on.exit"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySystemRunFinalizersOnExitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.notify.while.not.synchronized"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyNotifyWhileNotSynchronizedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.wait.call.not.in.loop"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyWaitCallNotInLoopInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.wait.while.not.synchronized"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyWaitWhileNotSynchronizedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.synchronization.on.non.final.field"
                     groupKey="inspection.threading" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizationOnNonFinalFieldInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.synchronization.on.variable.initialized.with.literal" groupKey="inspection.threading"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizationOnVariableInitializedWithLiteralInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.unsynchronized.method.overrides.synchronized.method" groupKey="inspection.threading"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyUnsynchronizedMethodOverridesSynchronizedMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.while.loop.spins.on.field"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyWhileLoopSpinsOnFieldInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.method.parameter.count" groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyMethodParameterCountInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.overly.complex.method"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyOverlyComplexMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.overly.long.method"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyOverlyLongMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.overly.nested.method"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyOverlyNestedMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.method.with.more.than.three.negations"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyMethodWithMoreThanThreeNegationsInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.multiple.return.points.per.method"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyMultipleReturnPointsPerMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.nested.switch"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNestedSwitchInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.conditional"
                     groupKey="inspection.style"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.clashing.getters" groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.ClashingGettersInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.package.mismatch" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrPackageInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.deprecated.api.usage" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrDeprecatedAPIUsageInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.nested.conditional"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNestedConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.negated.conditional"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNegatedConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.in.argument.check"
                     enabledByDefault="true" groupKey="inspection.bugs"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyInArgumentCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.negated.if"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNegatedIfInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.result.of.increment.or.decrement.used"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyResultOfIncrementOrDecrementUsedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" enabledByDefault="true"
                     key="inspection.display.name.reassigned.in.closure.local.var"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrReassignedInClosureLocalVarInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.unnecessary.qualified.reference" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.UnnecessaryQualifiedReferenceInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.empty.statement.body"
                     groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyEmptyStatementBodyInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.pointless.boolean" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyPointlessBooleanInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.pointless.arithmetic"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyPointlessArithmeticInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.double.negation"
                     groupKey="inspection.confusing"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyDoubleNegationInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.overly.complex.arithmetic.expression"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyOverlyComplexArithmeticExpressionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.clashing.trait.methods"
                     groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.ClashingTraitMethodsInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.annotation.references.unknown.identifier"
                     groupKey="inspection.annotations" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GrAnnotationReferencingUnknownIdentifiers"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.non.extending.permitted.subclasses"
                     level="ERROR"
                     groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GrPermitsClauseInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.switch.exhaustiveness.check"
                     level="WEAK WARNING"
                     groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GrSwitchExhaustivenessCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.pojo.without.compile.static"
                     level="WARNING"
                     groupKey="inspection.annotations" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.cs.GrPOJOInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.unresolved.labels.in.named.variant"
                     groupKey="inspection.annotations" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GrNamedVariantLabelsInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.overly.complex.boolean.expression"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyOverlyComplexBooleanExpressionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.octal.integer"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyOctalIntegerInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.gstring.key"
                     groupKey="inspection.confusing"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyGStringKeyInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.implicit.null.argument"
                     level="WEAK WARNING"
                     groupKey="inspection.confusing"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyImplicitNullArgumentCallInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.string.style.violation"
                     level="WEAK WARNING"
                     groupKey="inspection.style"
                     enabledByDefault="false"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.string.GrStringStyleViolationInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.duplicate.switch.branch"
                     groupKey="inspection.validity"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.validity.GroovyDuplicateSwitchBranchInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.non.short.circuit.boolean"
                     groupKey="inspection.bugs"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyNonShortCircuitBooleanInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.infinite.loop.statement"
                     groupKey="inspection.bugs"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyInfiniteLoopStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.infinite.recursion"
                     groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyInfiniteRecursionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.divide.by.zero"
                     groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyDivideByZeroInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.result.of.object.allocation.ignored"
                     groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyResultOfObjectAllocationIgnoredInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.access.to.inaccessible.element" groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyAccessibilityInspection" unfair="true"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.constructor.named.arguments" groupKey="inspection.bugs"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyConstructorNamedArgumentsInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.groovydoc.check"
                     groupKey="inspection.bugs"
                     enabledByDefault="true" level="ERROR"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyDocCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.incorrect.range.argument" groupKey="inspection.bugs"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyRangeTypeCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.new.instance.of.singleton" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.NewInstanceOfSingletonInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.check.labeled.statement" groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyLabeledStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.class.naming.convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.NewGroovyClassNamingConventionInspection"/>
    <inspectionElementsMerger implementation="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyClassNamingConventionMerger"/>

    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.local.variable.naming.convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyLocalVariableNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.static.method.naming.convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyStaticMethodNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.static.variable.naming.convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyStaticVariableNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.instance.method.naming.convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyInstanceMethodNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.instance.variable.naming.convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyInstanceVariableNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.constant.naming.convention" groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyConstantNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.parameter.naming.convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyParameterNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.map.get.can.be.keyed.access"
                     groupKey="inspection.gpath"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyMapGetCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.map.put.can.be.keyed.access"
                     groupKey="inspection.gpath"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyMapPutCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.list.get.can.be.keyed.access"
                     groupKey="inspection.gpath"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyListGetCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     key="inspection.display.name.list.set.can.be.keyed.access"
                     groupKey="inspection.gpath"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyListSetCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.untyped.access"
                     groupKey="inspection.bugs"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.untypedUnresolvedAccess.GroovyUntypedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.unresolved.access"
                     groupKey="inspection.bugs"
                     enabledByDefault="true" level="WEAK WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.untypedUnresolvedAccess.GrUnresolvedAccessInspection"/>

    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.annotations"
                     key="inspection.display.name.singleton.constructor" enabledByDefault="true" level="ERROR"
                     implementationClass="org.jetbrains.plugins.groovy.transformations.singleton.SingletonConstructorInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" key="inspection.display.name.delegates.to"
                     groupKey="inspection.annotations" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.DelegatesToInspection"/>

    <localInspection language="Groovy"
                     groupPath="Groovy"
                     groupKey="inspection.data.flow"
                     key="inspection.display.name.variable.can.be.final"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.dataflow.GroovyVariableCanBeFinalInspection"/>

    <localInspection language="Groovy"
                     groupPath="Groovy"
                     groupKey="inspection.bugs"
                     key="inspection.display.name.equals.between.inconvertible.types"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GrEqualsBetweenInconvertibleTypesInspection"/>

    <packageDependencies.visitor language="Groovy"
                                 implementationClass="org.jetbrains.plugins.groovy.codeInspection.dependencies.GrDependencyVisitorFactory"/>

    <implicitUsageProvider implementation="org.jetbrains.plugins.groovy.findUsages.GrImplicitUsageProvider"/>
    <implicitUsageProvider implementation="org.jetbrains.plugins.groovy.transformations.impl.synch.SynchronizedImplicitUsageProvider"/>

    <java.programPatcher implementation="org.jetbrains.plugins.groovy.debugger.GroovyHotSwapper"/>
    <applicationService serviceInterface="org.jetbrains.plugins.groovy.codeInspection.GroovyQuickFixFactory"
                        serviceImplementation="org.jetbrains.plugins.groovy.codeInspection.GroovyQuickFixFactoryImpl"/>

    <debugger.positionManagerFactory id="groovyPositionManager"
                                     implementation="org.jetbrains.plugins.groovy.debugger.GroovyPositionManagerFactory"/>
    <debugger.positionManagerFactory order="after groovyPositionManager"
                                     implementation="org.jetbrains.plugins.groovy.springloaded.SpringLoadedPositionManagerFactory"/>
    <debugger.nodeRenderer implementation="org.jetbrains.plugins.groovy.debugger.GroovyRefRenderer"/>
    <codeStyle.ReferenceAdjuster language="Groovy" implementationClass="org.jetbrains.plugins.groovy.codeStyle.GrReferenceAdjuster"/>
    <codeInsight.unresolvedReferenceQuickFixProvider implementation="org.jetbrains.plugins.groovy.jarFinder.GroovyFindJarQuickFixProvider"/>
    <lang.refactoringSupport.classMembersRefactoringSupport language="Groovy"
                                                            implementationClass="org.jetbrains.plugins.groovy.refactoring.classMembers.GroovyClassMembersRefactoringSupport"/>
    <refactoring.pullUpHelperFactory language="Groovy"
                                     implementationClass="org.jetbrains.plugins.groovy.refactoring.memberPullUp.GrPullUpHelperFactory"/>
    <classTypePointerFactory implementation="org.jetbrains.plugins.groovy.lang.psi.impl.smartPointers.GrClassReferenceTypePointerFactory"/>
    <hierarchy.referenceProcessor implementation="org.jetbrains.plugins.groovy.hierarchy.call.GrCallReferenceProcessor"/>


    <applicationService serviceImplementation="org.jetbrains.plugins.groovy.dsl.DslActivationStatus"/>

    <refactoring.introduceParameterObject language="Groovy"
                                          implementationClass="org.jetbrains.plugins.groovy.refactoring.introduceParameterObject.GroovyIntroduceParameterObjectDelegate"/>
    <documentationDelegateProvider implementation="org.jetbrains.plugins.groovy.lang.documentation.GrLightDocumentationDelegateProvider"/>
    <breadcrumbsInfoProvider implementation="org.jetbrains.plugins.groovy.editor.GroovyBreadcrumbsInfoProvider"/>
    <stripTrailingSpacesFilterFactory implementation="org.jetbrains.plugins.groovy.editor.GroovyStripTrailingSpacesFilterFactory"/>
    <generateAccessorProvider implementation="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateAccessorProvider"/>
    <consoleFilterProvider implementation="org.jetbrains.plugins.groovy.execution.filters.GrCompilationErrorsFilterProvider"/>
    <outOfSourcesChecker implementation="org.jetbrains.plugins.groovy.projectRoots.GroovyOutOfSourcesChecker"/>

    <externalSystemConfigurationHandler implementation="org.jetbrains.plugins.groovy.compiler.GroovyCompilerGradleConfigurationHandler"/>
    <compilableFileTypesProvider implementation="org.jetbrains.plugins.groovy.compiler.GroovyCompilableFileTypesProvider"/>

    <notificationGroup id="Groovy DSL errors" displayType="BALLOON" bundle="messages.GroovyBundle" key="notification.group.groovy.dsl"/>
    <notificationGroup id="Grape" displayType="BALLOON" bundle="messages.GroovyBundle" key="notification.group.grape"/>
    <newProjectWizard.languageGenerator implementation="org.jetbrains.plugins.groovy.config.wizard.GroovyNewProjectWizard"/>
    <newProjectWizard.groovy.buildSystem implementation="org.jetbrains.plugins.groovy.config.wizard.IntelliJGroovyNewProjectWizard"/>

    <persistentFsConnectionListener implementation="org.jetbrains.plugins.groovy.bundled.BundledGroovyPersistentFsConnectionListener"/>

    <internal.statistic.libraryUsageImportProcessor language="Groovy"
                                                    implementationClass="org.jetbrains.plugins.groovy.stats.GroovyLibraryUsageImportProcessor"/>
    <iconMapper mappingFile="GroovyIconMappings.json"/>
  </extensions>

  <extensions defaultExtensionNs="com.intellij.debugger">
    <codeFragmentFactory implementation="org.jetbrains.plugins.groovy.debugger.GroovyCodeFragmentFactory"/>
  </extensions>

  <actions>
    <group id="Groovy.CheckResources" popup="true">
      <action class="org.jetbrains.plugins.groovy.compiler.CheckResourcesAction$Make" id="Groovy.CheckResources.Make"/>
      <action class="org.jetbrains.plugins.groovy.compiler.CheckResourcesAction$Rebuild" id="Groovy.CheckResources.Rebuild"/>
      <add-to-group group-id="BuildMenu"/>
    </group>

    <action id="Groovy.NewClass" class="org.jetbrains.plugins.groovy.actions.NewGroovyClassAction">
      <add-to-group group-id="NewGroup" anchor="after" relative-to-action="NewGroup1"/>
    </action>
    <action id="Groovy.NewScript" class="org.jetbrains.plugins.groovy.actions.NewScriptAction">
      <add-to-group group-id="NewGroup" anchor="last"/>
    </action>

    <action id="ConvertGroovyToJava"
            class="org.jetbrains.plugins.groovy.actions.ConvertToJavaAction">
      <add-to-group group-id="RefactoringMenu"/>
    </action>

    <action id="ConvertToCompileStatic"
            class="org.jetbrains.plugins.groovy.actions.ConvertToStaticAction">
      <add-to-group group-id="RefactoringMenu"/>
    </action>

    <action id="DumpGroovyControlFlowAction"
            class="org.jetbrains.plugins.groovy.actions.DumpGroovyControlFlowAction"
            internal="true">
      <add-to-group group-id="Internal"/>
    </action>

    <action id="ExcludeFromStubGeneration"
            class="org.jetbrains.plugins.groovy.compiler.ExcludeFromStubGenerationAction">
      <add-to-group group-id="EditorTabPopupMenu"/>
    </action>


    <group id="GroovyGenerateGroup1">
      <!--suppress PluginXmlCapitalization -->
      <action id="org.jetbrains.plugins.groovy.actions.generate.tostring.GroovyGenerateToStringAction"
              class="org.jetbrains.plugins.groovy.actions.generate.tostring.GroovyGenerateToStringAction"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.constructors.GroovyGenerateConstructorAction"
              class="org.jetbrains.plugins.groovy.actions.generate.constructors.GroovyGenerateConstructorAction"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterAction"
              class="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterAction"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateSetterAction"
              class="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateSetterAction"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterSetterAction"
              class="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterSetterAction"/>
      <!--suppress PluginXmlCapitalization -->
      <action id="org.jetbrains.plugins.groovy.actions.generate.equals.GroovyGenerateEqualsAction"
              class="org.jetbrains.plugins.groovy.actions.generate.equals.GroovyGenerateEqualsAction"/>
      <!--suppress PluginXmlCapitalization -->
      <action id="org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGenerateMethodMissingAction"
              class="org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGenerateMethodMissingAction"/>
      <!--suppress PluginXmlCapitalization -->
      <action id="org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGeneratePropertyMissingAction"
              class="org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGeneratePropertyMissingAction"/>

      <add-to-group group-id="GenerateGroup" anchor="after" relative-to-action="JavaGenerateGroup1"/>
    </group>
  </actions>

  <extensions defaultExtensionNs="org.jetbrains.uast">
    <uastLanguagePlugin implementation="org.jetbrains.plugins.groovy.lang.psi.uast.GroovyUastPlugin"/>
  </extensions>

  <extensions defaultExtensionNs="com.intellij.jvm">
    <declarationSearcher language="Groovy" implementationClass="org.jetbrains.plugins.groovy.jvm.GroovyDeclarationSearcher"/>
  </extensions>

  <xi:include href="groovy-intentions.xml" xpointer="xpointer(/idea-plugin/*)"/>
  <xi:include href="groovy-console.xml" xpointer="xpointer(/idea-plugin/*)"/>
  <xi:include href="groovy-templates.xml" xpointer="xpointer(/idea-plugin/*)"/>
  <xi:include href="groovy-dynamic-members.xml" xpointer="xpointer(/idea-plugin/*)"/>
  <xi:include href="groovy-indexed-property-support.xml" xpointer="xpointer(/idea-plugin/*)"/>
  <xi:include href="groovy-logback-support.xml" xpointer="xpointer(/idea-plugin/*)"/>
  <xi:include href="geb-support.xml" xpointer="xpointer(/idea-plugin/*)"/>
  <xi:include href="gant-support.xml" xpointer="xpointer(/idea-plugin/*)"/>
</idea-plugin>