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

<idea-plugin xmlns:xi="http://www.w3.org/2001/XInclude">
  <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>
  <depends>com.intellij.properties</depends>
  <depends>com.intellij.modules.java</depends>

  <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>
  <depends optional="true" config-file="ant.xml">AntSupport</depends>
  <depends optional="true" config-file="groovy-byte-code-viewer.xml">ByteCodeViewer</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>

  <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" interface="org.jetbrains.plugins.groovy.lang.resolve.GrMethodComparator"/>
    <extensionPoint name="overloadResolver" interface="org.jetbrains.plugins.groovy.lang.resolve.api.GroovyOverloadResolver"/>
    <extensionPoint name="membersContributor" interface="org.jetbrains.plugins.groovy.lang.resolve.NonCodeMembersContributor"/>
    <extensionPoint name="importContributor" interface="org.jetbrains.plugins.groovy.lang.resolve.imports.GrImportContributor"/>
    <extensionPoint name="astTransformationSupport" interface="org.jetbrains.plugins.groovy.transformations.AstTransformationSupport"/>
    <extensionPoint name="renameHelper" interface="org.jetbrains.plugins.groovy.refactoring.rename.GrRenameHelper"/>
    <extensionPoint name="closureMissingMethodContributor"
                    interface="org.jetbrains.plugins.groovy.lang.resolve.ClosureMissingMethodContributor"/>
    <extensionPoint name="variableEnhancer" interface="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrVariableEnhancer"/>
    <extensionPoint name="typeAugmenter" interface="org.jetbrains.plugins.groovy.lang.psi.dataFlow.types.TypeAugmenter"/>
    <extensionPoint name="referenceTypeEnhancer" interface="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrReferenceTypeEnhancer"/>
    <extensionPoint name="typeConverter" interface="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrTypeConverter"/>
    <extensionPoint name="expectedTypesContributor"
                    interface="org.jetbrains.plugins.groovy.lang.psi.expectedTypes.GroovyExpectedTypesContributor"/>

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

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

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

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

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

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

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

    <extensionPoint name="mvc.framework" interface="org.jetbrains.plugins.groovy.mvc.MvcFramework"/>
    <extensionPoint name="mvc.command.executor" interface="org.jetbrains.plugins.groovy.mvc.MvcCommandExecutor"/>

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

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

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

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

    <extensionPoint name="signatureHintProcessor" interface="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.SignatureHintProcessor"/>
    <extensionPoint name="mvc.runCommandHandler" interface="org.jetbrains.plugins.groovy.mvc.actions.MvcRunCommandActionHandler"/>
    <extensionPoint name="gdslScriptProvider" interface="org.jetbrains.plugins.groovy.dsl.GdslScriptProvider"/>
    <extensionPoint name="expectedPackageNameProvider" interface="org.jetbrains.plugins.groovy.lang.resolve.ExpectedPackageNameProvider"/>
    <extensionPoint name="delegatesToProvider" interface="org.jetbrains.plugins.groovy.lang.resolve.delegatesTo.GrDelegatesToProvider"/>
    <extensionPoint name="elementFilter" interface="org.jetbrains.plugins.groovy.lang.GroovyElementFilter"/>
    <extensionPoint name="inlayHintFilter" 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.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"/>

    <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.ConstructorAnnotationsProcessor"/>
    <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="defaultSupport"
                              implementation="org.jetbrains.plugins.groovy.transformations.impl.DefaultTransformationSupport"/>
    <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"/>

    <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"/>

    <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.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"/>
    <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"/>

    <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.ClosureAsAnonymousParameterEnhancer"/>

    <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.ImmutableOptionsAnnotationChecker"/>

    <convertToJava.customMethodInvocator
        implementation="org.jetbrains.plugins.groovy.refactoring.convertToJava.invocators.MapGetterSetterInvocator"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.TypeCheckedAnnotationChecker"/>
    <mvc.runCommandHandler implementation="org.jetbrains.plugins.groovy.mvc.actions.DefaultMvcRunCommandActionHandler" order="last"/>
    <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"
              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"/>

    <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="true"
                 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"/>

    <postStartupActivity implementation="org.jetbrains.plugins.groovy.mvc.MvcModuleStructureSynchronizer$MyPostStartUpActivity"/>

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

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

    <fileTypeDetector implementation="org.jetbrains.plugins.groovy.GroovyHashBangFileTypeDetector"/>

    <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"/>
    <!-- In Android Studio, we don't want editor notifications to setup Groovy Path when *.gradle files are opened. This is a temporary
    hack to remove this until we figure out how to disable it just for gradle scripts.
    <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"/>
    <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.inlayProvider language="Groovy" implementationClass="org.jetbrains.plugins.groovy.codeInsight.hint.GroovyParameterTypeHintsInlayProvider"/>
    <codeInsight.parameterNameHints
        language="Groovy" implementationClass="org.jetbrains.plugins.groovy.codeInsight.hint.GroovyInlayParameterHintsProvider"
    />

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

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

    <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"/>

    <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"/>

    <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"/>

    <liveTemplateContext implementation="org.jetbrains.plugins.groovy.template.GroovyTemplateContextType$Generic"/>
    <liveTemplateContext implementation="org.jetbrains.plugins.groovy.template.GroovyTemplateContextType$Expression"/>
    <liveTemplateContext implementation="org.jetbrains.plugins.groovy.template.GroovyTemplateContextType$Statement"/>
    <liveTemplateContext 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"/>
    <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.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.shell.GroovyShellCompletionContributor"/>

    <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"/>
    <externalSystem.codeStyleConfigurationImporter implementation="org.jetbrains.plugins.groovy.codeStyle.GroovyCodeStyleImporter"/>


    <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"/>


    <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"/>
    <!-- Android Studio: disable Groovy script producer - we don't want this to be offered for random .gradle files, esp. build.gradle (Change I5983550c / commit ff49f5d)
    <runConfigurationProducer implementation="org.jetbrains.plugins.groovy.runner.ScriptRunConfigurationProducer"/>
    -->

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

    <compileServer.plugin classpath="groovy-jps-plugin.jar;groovy-rt-constants.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"
                         bundle="messages.GroovyBundle"
                         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"/>

    <vetoSPICondition implementation="org.jetbrains.plugins.groovy.dgm.GroovyExtensionVetoSPI"/>

    <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.GrFullClassNameIndex"/>
    <stubIndex implementation="org.jetbrains.plugins.groovy.lang.psi.stubs.index.GrFullScriptNameIndex"/>
    <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.ConstructorReferencesSearcher"/>
    <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"/>

    <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"/>

    <fileBasedIndex implementation="org.jetbrains.plugins.groovy.lang.resolve.GroovyTraitFieldsFileIndex"/>
    <fileBasedIndex implementation="org.jetbrains.plugins.groovy.lang.resolve.GroovyTraitMethodsFileIndex"/>

    <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"/>

    <postStartupActivity implementation="org.jetbrains.plugins.groovy.mvc.MvcProjectWithoutLibraryNotificator"/>

    <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" displayName="Unused declaration"
                     groupPath="Groovy"
                     groupKey="inspection.redundancy" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.GroovyUnusedDeclarationInspection" unfair="true"/>

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

    <!-- Android Studio: Turned off by default. Lots of false positives in build.gradle files, the main use of Groovy in Studio -->
    <localInspection language="Groovy"
                     groupPath="Groovy"
                     displayName="Incompatible type assignments"
                     groupKey="inspection.assignments"
                     enabledByDefault="false"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignabilityCheckInspection"/>

    <localInspection language="Groovy" groupPath="Groovy" displayName="Result of assignment used"
                     groupKey="inspection.assignments"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyResultOfAssignmentUsedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Assignment replaceable with operator assignment"
                     groupKey="inspection.assignments"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignmentCanBeOperatorAssignmentInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Assignment to for-loop parameter"
                     groupKey="inspection.assignments"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignmentToForLoopParameterInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Assignment to method parameter"
                     groupKey="inspection.assignments"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignmentToMethodParameterInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Nested assignment"
                     groupKey="inspection.assignments"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyNestedAssignmentInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Silly assignment"
                     groupKey="inspection.assignments" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovySillyAssignmentInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Unchecked assignment from members of raw type"
                     groupKey="inspection.assignments" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyUncheckedAssignmentOfMemberOfRawTypeInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="'continue' or 'break' inside 'finally' block"
                     groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyContinueOrBreakFromFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Method may be static"
                     groupName="Declaration" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.declaration.GrMethodMayBeStaticInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="'return' inside 'finally' block" groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyReturnFromFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="'throw' inside 'finally' block" groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyThrowFromFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Empty 'catch' block"
                     groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyEmptyCatchBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Empty 'finally' block"
                     groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyEmptyFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Empty 'try' block"
                     groupKey="inspection.error.handling"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyEmptyTryBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Unused catch parameter"
                     groupKey="inspection.error.handling"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyUnusedCatchParameterInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Break statement"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyBreakInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Continue statement"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyContinueInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Unreachable statement"
                     groupKey="inspection.validity"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.validity.GroovyUnreachableStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Loop statement that doesn't loop" groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyLoopStatementThatDoesntLoopInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Conditional expression with identical branches"
                     groupKey="inspection.control.flow" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConditionalWithIdenticalBranchesInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Conditional expression can be elvis" groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConditionalCanBeElvisInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Conditional expression can be conditional call"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConditionalCanBeConditionalCallInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="If statement with identical branches"
                     groupKey="inspection.control.flow" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyIfStatementWithIdenticalBranchesInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="If statement with too many branches"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyIfStatementWithTooManyBranchesInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Fallthrough in switch statement"
                     groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyFallthroughInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Unnecessary 'continue' statement" groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyUnnecessaryContinueInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Unnecessary 'return' statement"
                     groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyUnnecessaryReturnInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Final variable access"
                     groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.finalVar.GrFinalVariableAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Switch statement with no default case"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovySwitchStatementWithNoDefaultInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="'return' statement can be implicit"
                     groupKey="inspection.control.flow"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyReturnFromClosureCanBeImplicitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Redundant conditional expression" groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyTrivialConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Constant conditional expression" groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConstantConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Constant if statement"
                     groupKey="inspection.control.flow"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConstantIfStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Redundant 'if' statement"
                     groupKey="inspection.control.flow" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyTrivialIfInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Java-style property access"
                     groupKey="inspection.style" enabledByDefault="true" level="INFORMATION"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.JavaStylePropertiesInvocationInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     displayName="Unnecessary 'def'" cleanupTool="true" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessaryDefModifierInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     displayName="Unnecessary 'public'" cleanupTool="true" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessaryPublicModifierInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     displayName="Unnecessary semicolon" cleanupTool="true" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessarySemicolonInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.style"
                     displayName="Unnecessary import alias" cleanupTool="true" enabledByDefault="true" level="WEAK WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.GrUnnecessaryAliasInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Change to operator"
                     groupKey="inspection.style" enabledByDefault="true" level="WEAK WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.changeToOperator.ChangeToOperatorInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Change to method"
                     groupKey="inspection.style" enabledByDefault="true" level="INFORMATION"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.changeToMethod.ChangeToMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Access to static field locked on instance data"
                     groupKey="inspection.threading" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyAccessToStaticFieldLockedOnInstanceInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Double-checked locking"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyDoubleCheckedLockingInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Unconditional 'wait' call"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyUnconditionalWaitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Non-private field accessed in synchronized context" groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyPublicFieldAccessedInSynchronizedContextInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Busy wait" groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyBusyWaitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Empty 'synchronized' block"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyEmptySyncBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Synchronization on 'this'"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizationOnThisInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Synchronized method"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizedMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Nested 'synchronized' statement"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyNestedSynchronizedStatementInspection"/>
    <!--suppress PluginXmlCapitalization -->
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Call to Thread.stop(), Thread.suspend(), or Thread.resume()"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyThreadStopSuspendResumeInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Call to System.runFinalizersOnExit()"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySystemRunFinalizersOnExitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="'notify()' or 'notifyAll()' while not synced"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyNotifyWhileNotSynchronizedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="'wait()' not in loop"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyWaitCallNotInLoopInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="'wait()' while not synced"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyWaitWhileNotSynchronizedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Synchronization on non-final field"
                     groupKey="inspection.threading" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizationOnNonFinalFieldInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Synchronization on variable initialized with literal" groupKey="inspection.threading"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizationOnVariableInitializedWithLiteralInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Unsynchronized method overrides synchronized method" groupKey="inspection.threading"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyUnsynchronizedMethodOverridesSynchronizedMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="While loop spins on field"
                     groupKey="inspection.threading"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyWhileLoopSpinsOnFieldInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Method with too many parameters" groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyMethodParameterCountInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Overly complex method"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyOverlyComplexMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Overly long method"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyOverlyLongMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Overly nested method"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyOverlyNestedMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Method with more than three negations"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyMethodWithMoreThanThreeNegationsInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Method with multiple return points"
                     groupKey="inspection.method.metrics"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyMultipleReturnPointsPerMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Nested switch statement"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNestedSwitchInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Conditional expression"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     key="clashing.getters" groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.ClashingGettersInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     key="gr.package" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrPackageInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     key="gr.deprecated.api.usage" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrDeprecatedAPIUsageInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Nested conditional expression"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNestedConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Negated conditional expression"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNegatedConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Incompatible 'in' argument types"
                     enabledByDefault="true" groupKey="inspection.bugs"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyInArgumentCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Negated if condition expression"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNegatedIfInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Result of increment or decrement used"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyResultOfIncrementOrDecrementUsedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" enabledByDefault="true"
                     displayName="Local variable is reassigned in closure or anonymous class"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrReassignedInClosureLocalVarInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     key="unnecessary.qualified.reference" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.UnnecessaryQualifiedReferenceInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Statement with empty body"
                     groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyEmptyStatementBodyInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     key="pointless.boolean.display.name" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyPointlessBooleanInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Pointless arithmetic expression"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyPointlessArithmeticInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Double negation"
                     groupKey="inspection.confusing"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyDoubleNegationInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Overly complex arithmetic expression"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyOverlyComplexArithmeticExpressionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Clashing trait methods"
                     groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.ClashingTraitMethodsInspection"/>

    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Overly complex boolean expression"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyOverlyComplexBooleanExpressionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Octal integer"
                     groupKey="inspection.confusing"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyOctalIntegerInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="GString map key"
                     groupKey="inspection.confusing"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyGStringKeyInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Duplicate switch case"
                     groupKey="inspection.validity"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.validity.GroovyDuplicateSwitchBranchInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Non short-circuit boolean"
                     groupKey="inspection.bugs"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyNonShortCircuitBooleanInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Infinite loop statement"
                     groupKey="inspection.bugs"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyInfiniteLoopStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Infinite recursion"
                     groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyInfiniteRecursionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Divide by zero"
                     groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyDivideByZeroInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Result of object allocation ignored"
                     groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyResultOfObjectAllocationIgnoredInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     key="access.to.inaccessible.element" groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyAccessibilityInspection" unfair="true"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Named arguments of constructor call" groupKey="inspection.bugs"
                     enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyConstructorNamedArgumentsInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="GroovyDoc issues"
                     groupKey="inspection.bugs"
                     enabledByDefault="true" level="ERROR"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyDocCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     key="incorrect.range.argument" groupKey="inspection.bugs"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyRangeTypeCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     key="new.instance.of.singleton" groupKey="inspection.confusing" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.NewInstanceOfSingletonInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     key="check.labeled.statement" groupKey="inspection.bugs" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyLabeledStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="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"
                     displayName="Local variable naming convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyLocalVariableNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Static method naming convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyStaticMethodNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Static variable naming convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyStaticVariableNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Instance method naming convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyInstanceMethodNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Instance variable naming convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyInstanceVariableNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Constant naming convention" groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyConstantNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Method parameter naming convention"
                     groupKey="inspection.naming"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyParameterNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Call to Map.get can be keyed access"
                     groupKey="inspection.gpath"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyMapGetCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Call to Map.put can be keyed access"
                     groupKey="inspection.gpath"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyMapPutCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Call to List.get can be keyed access"
                     groupKey="inspection.gpath"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyListGetCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy"
                     displayName="Call to List.set can be keyed access"
                     groupKey="inspection.gpath"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyListSetCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="Access to untyped expression"
                     groupKey="inspection.bugs"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.untypedUnresolvedAccess.GroovyUntypedAccessInspection"/>
    <!-- Android Studio: Turned off by default. Lots of false positives in build.gradle files, the main use of Groovy in Studio -->
    <localInspection language="Groovy" groupPath="Groovy" displayName="Access to unresolved expression"
                     groupKey="inspection.bugs"
                     enabledByDefault="false" level="WEAK WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.untypedUnresolvedAccess.GrUnresolvedAccessInspection"/>

    <localInspection language="Groovy" groupPath="Groovy" groupKey="inspection.annotations"
                     bundle="messages.GroovyTransformationsBundle"
                     groupBundle="messages.GroovyBundle"
                     key="singleton.constructor.inspection" enabledByDefault="true" level="ERROR"
                     implementationClass="org.jetbrains.plugins.groovy.transformations.singleton.SingletonConstructorInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" displayName="@DelegatesTo inspection"
                     groupKey="inspection.annotations" enabledByDefault="true"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.DelegatesToInspection"/>

    <localInspection language="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupBundle="messages.GroovyBundle"
                     groupPath="Groovy"
                     groupKey="inspection.data.flow"
                     key="variable.can.be.final"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.dataflow.GroovyVariableCanBeFinalInspection"/>

    <localInspection language="Groovy"
                     groupPath="Groovy"
                     bundle="messages.GroovyInspectionBundle"
                     groupKey="groovy.probable.bugs"
                     key="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"/>
    <roots.watchedRootsProvider implementation="org.jetbrains.plugins.groovy.mvc.MvcWatchedRootProvider"/>
    <projectService serviceImplementation="org.jetbrains.plugins.groovy.mvc.MvcConsole"/>
    <applicationService serviceImplementation="org.jetbrains.plugins.groovy.mvc.MvcRunTargetHistoryService"/>
    <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"/>
    <postStartupActivity implementation="org.jetbrains.plugins.groovy.compiler.GroovyCompilerLoader"/>

    <pathMacroContributor implementation="org.jetbrains.plugins.groovy.mvc.MvcPathMacros"/>
    <notificationWhitelist groupIds="Groovy DSL errors;Grape;Mvc notifications;"/>
  </extensions>

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

  <actions>
    <action id="Groovy.Shell.Execute" class="com.intellij.openapi.actionSystem.EmptyAction" use-shortcut-of="Console.Execute.Multiline"/>

    <group id="Groovy.CheckResources" class="org.jetbrains.plugins.groovy.compiler.CheckResourcesAction$Group"
           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>

    <action id="Groovy.Doc.Generating"
            class="org.jetbrains.plugins.groovy.doc.actions.GenerateGroovyDocAction"
            icon="JetgroovyIcons.Groovy.GroovyDoc">
      <add-to-group group-id="ToolsMenu" anchor="last"/>
    </action>

    <action id="Groovy.Shell"
            class="org.jetbrains.plugins.groovy.shell.GroovyShellAction"
            icon="JetgroovyIcons.Groovy.Groovy_16x16">
      <add-to-group group-id="ToolsMenu" anchor="last"/>
    </action>

    <group id="Mvc.Actions" popup="true" class="org.jetbrains.plugins.groovy.mvc.MvcActionGroup">
      <action id="Mvc.Upgrade"
              class="org.jetbrains.plugins.groovy.mvc.MvcUpgradeAction">
      </action>

      <action id="Mvc.RunTarget" class="org.jetbrains.plugins.groovy.mvc.actions.MvcRunCommandAction">
        <keyboard-shortcut keymap="$default" first-keystroke="ctrl alt G"/>
      </action>
      <add-to-group group-id="ProjectViewPopupMenu" anchor="after" relative-to-action="AddFrameworkSupport"/>
      <add-to-group group-id="NavbarPopupMenu" anchor="after" relative-to-action="AddFrameworkSupport"/>
      <add-to-group group-id="ToolsMenu" anchor="last"/>
    </group>

    <action id="groovy.scripting.shell"
            class="org.jetbrains.plugins.groovy.ide.GroovyScriptingShellAction"/>
  </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="spock-support.xml" xpointer="xpointer(/idea-plugin/*)"/>
  <xi:include href="gant-support.xml" xpointer="xpointer(/idea-plugin/*)"/>
</idea-plugin>