<!--
  ~  Copyright 2000-2009 JetBrains s.r.o.
  ~  Licensed under the Apache License, Version 2.0 (the "License");
  ~  you may not use this file except in compliance with the License.
  ~  You may obtain a copy of the License at
  ~
  ~  http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~  Unless required by applicable law or agreed to in writing, software
  ~  distributed under the License is distributed on an "AS IS" BASIS,
  ~  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  ~  See the License for the specific language governing permissions and
  ~  limitations under the License.
  ~
  -->
<idea-plugin>
  <id>org.intellij.groovy</id>
  <name>Groovy</name>
  <description>Plugin for Groovy language support, including Groovy++, Grape, Gant and Griffon</description>
  <version>9.0</version>
  <vendor>JetBrains</vendor>
  <depends>com.intellij.properties</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">AntSupport</depends>
  <depends optional="true" config-file="groovy-byte-code-viewer.xml">ByteCodeViewer</depends>

  <extensionPoints>
    <extensionPoint name="methodComparator" interface="org.jetbrains.plugins.groovy.lang.resolve.GrMethodComparator"/>
    <extensionPoint name="membersContributor" interface="org.jetbrains.plugins.groovy.lang.resolve.NonCodeMembersContributor"/>
    <extensionPoint name="defaultImportContributor" interface="org.jetbrains.plugins.groovy.lang.resolve.DefaultImportContributor"/>
    <extensionPoint name="astTransformContributor" interface="org.jetbrains.plugins.groovy.lang.resolve.ast.AstTransformContributor"/>
    <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="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="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="callExpressionTypeCalculator"
                    interface="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrCallExpressionTypeCalculator"/>
    <extensionPoint name="classDescriptor" beanClass="org.jetbrains.plugins.groovy.extensions.GroovyClassDescriptor"/>
    <extensionPoint name="methodDescriptor" beanClass="org.jetbrains.plugins.groovy.extensions.GroovyMethodDescriptorExtension"/>

    <extensionPoint name="groovyShellRunner" interface="org.jetbrains.plugins.groovy.console.GroovyShellRunner"/>

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

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

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

    <membersContributor implementation="org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicMembersContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.noncode.GrCollectionTypeMembersProvider"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.spock.SpockMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.noncode.MixinMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.swingBuilder.SwingBuilderNonCodeMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.dgm.DGMMemberContributor"/>

    <membersContributor implementation="org.jetbrains.plugins.groovy.geb.GebSpockTestMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.geb.GebPageMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.geb.GebModuleMemberContributor"/>

    <membersContributor implementation="org.jetbrains.plugins.groovy.geb.GebJUnitTestMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.geb.GebTestNGTestMemberContributor"/>
    <membersContributor implementation="org.jetbrains.plugins.groovy.geb.GebBrowserMemberContributor"/>

    <membersContributor implementation="org.jetbrains.plugins.groovy.gant.GantMemberContributor"/>

    <membersContributor implementation="org.jetbrains.plugins.groovy.markup.XmlMarkupBuilderNonCodeMemberContributor"/>

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

    <astTransformContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.DelegatedMethodsContributor"/>
    <astTransformContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.AutoExternalizeContributor"/>
    <astTransformContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.AutoCloneContributor"/>
    <astTransformContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.ConstructorAnnotationsProcessor"/>
    <astTransformContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.GrInheritConstructorContributor"/>
    <astTransformContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.ast.LoggingContributor"/>

    <positionManagerDelegate implementation="org.jetbrains.plugins.groovy.gant.GantPositionManagerHelper"/>

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

    <callExpressionTypeCalculator
        implementation="org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.path.DefaultCallExpressionTypeCalculator"
        order="last"/>
    <callExpressionTypeCalculator
        implementation="org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.path.GrDescriptorReturnTypeCalculator"/>
    <callExpressionTypeCalculator
        implementation="org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.path.GrDGMTypeCalculator"/>

    <scriptTypeDetector implementation="org.jetbrains.plugins.groovy.gant.GantScriptTypeDetector"/>

    <namedArgumentProvider implementation="org.jetbrains.plugins.groovy.lang.GroovySourceCodeNamedArgumentProvider" order="last"/>
    <namedArgumentProvider implementation="org.jetbrains.plugins.groovy.lang.GroovyConstructorNamedArgumentProvider"/>
    <namedArgumentProvider implementation="org.jetbrains.plugins.groovy.lang.GroovyMethodReturnNamedArgumentProvider" order="last"/>


    <!-- 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.ClosureParameterEnhancer"/>
    <variableEnhancer implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ClosureAsAnonymousParameterEnhancer"/>
    <variableEnhancer implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ClosureParamsEnhancer"/>

    <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.GrContainerTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrStringTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrBooleanTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrGenericTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ClosureToSamConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrStringConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrContainerConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.gpp.GppTypeConverter"/>
    <typeConverter implementation="org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.GrNumberConverter"/>

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

    <mvc.framework implementation="org.jetbrains.plugins.groovy.griffon.GriffonFramework"/>
    <groovyFrameworkConfigNotification implementation="org.jetbrains.plugins.groovy.griffon.GriffonConfigureNotification"/>
    <defaultImportContributor implementation="org.jetbrains.plugins.groovy.griffon.GriffonDefaultImportContributor"/>

    <groovyShellRunner implementation="org.jetbrains.plugins.groovy.console.GroovyConsoleRunner" order="last"/>

    <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.griffon.GriffonPropertyListenerAnnotationChecker"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.BaseScriptAnnotationChecker"/>

    <convertToJava.customMethodInvocator
        implementation="org.jetbrains.plugins.groovy.refactoring.convertToJava.invocators.MapGetterSetterInvocator"/>
    <customAnnotationChecker implementation="org.jetbrains.plugins.groovy.annotator.checkers.TypeCheckedAnnotationChecker"/>
  </extensions>

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

  <extensions defaultExtensionNs="com.intellij">
    <navbar implementation="org.jetbrains.plugins.groovy.navbar.GrNavBarModelExtension" order="after defaultNavbar"/>

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


    <psi.clsCustomNavigationPolicy implementation="org.jetbrains.plugins.groovy.codeInsight.GroovyClsCustomNavigationPolicy"/>

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

    <pom.declarationSearcher implementation="org.jetbrains.plugins.groovy.geb.GebContentDeclarationSearcher"/>

    <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"/>
    <testFramework implementation="org.jetbrains.plugins.groovy.spock.SpockTestFramework" order="first"/>

    <testCreator language="Groovy" implementationClass="com.intellij.testIntegration.JavaTestCreator"/>
    <testGenerator language="Groovy" implementationClass="org.jetbrains.plugins.groovy.testIntegration.GroovyTestGenerator"/>
    <constructorBodyGenerator language="Groovy"
                              implementationClass="org.jetbrains.plugins.groovy.annotator.intentions.dynamic.GrConstructorBodyGenerator"/>
    <editorNotificationProvider implementation="org.jetbrains.plugins.groovy.config.ConfigureGroovyLibraryNotificationProvider"/>
    <refactoring.introduceParameterMethodUsagesProcessor
        implementation="org.jetbrains.plugins.groovy.refactoring.introduce.parameter.java2groovy.GroovyIntroduceParameterMethodUsagesProcessor"/>
    <refactoring.changeSignatureUsageProcessor
        implementation="org.jetbrains.plugins.groovy.refactoring.changeSignature.GrChangeSignatureUsageProcessor" id="groovyProcessor"
        order="before javaProcessor"/>
    <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"/>

    <errorHandler implementation="com.intellij.diagnostic.ITNReporter"/>
    <fileTypeFactory implementation="org.jetbrains.plugins.groovy.GroovyFileTypeLoader"/>
    <fileTypeFactory implementation="org.jetbrains.plugins.groovy.dgm.DGMFileTypeFactory"/>

    <projectConfigurable groupId="build" instance="org.jetbrains.plugins.groovy.gant.GantConfigurable" id="reference.settingsdialog.project.gant"
                         displayName="Gant"/>

    <library.presentationProvider implementation="org.jetbrains.plugins.groovy.config.GroovyLibraryPresentationProvider"/>
    <library.presentationProvider implementation="org.jetbrains.plugins.groovy.gpp.GppLibraryPresentationProvider" order="first"/>
    <library.presentationProvider implementation="org.jetbrains.plugins.groovy.gant.GantLibraryPresentationProvider" order="last"/>

    <projectService serviceInterface="org.jetbrains.plugins.groovy.gant.GantSettings"
                    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.GroovyColorsAndFontsPage"/>
    <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.RenameAliasImportedClassProcessor"
                               order="first"/>
    <renamePsiElementProcessor implementation="org.jetbrains.plugins.groovy.refactoring.rename.RenameAliasImportedMethodProcessor"
                               order="first"/>
    <renamePsiElementProcessor implementation="org.jetbrains.plugins.groovy.refactoring.rename.RenameGroovyScriptProcessor"/>

    <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 serviceInterface="org.jetbrains.plugins.groovy.settings.GroovyApplicationSettings"
                        serviceImplementation="org.jetbrains.plugins.groovy.settings.GroovyApplicationSettings"/>
    <applicationService serviceInterface="org.jetbrains.plugins.groovy.dsl.DslErrorReporter"
                        serviceImplementation="org.jetbrains.plugins.groovy.dsl.DslErrorReporterImpl"/>

    <!-- Groovy language -->
    <syntaxHighlighter key="Groovy" implementationClass="org.jetbrains.plugins.groovy.highlighter.GroovySyntaxHighlighter"/>

    <annotator language="Groovy" implementationClass="org.jetbrains.plugins.groovy.annotator.GrAnnotatorImpl"/>
    <annotator language="Groovy" implementationClass="org.jetbrains.plugins.groovy.dsl.GroovyDslAnnotator"/>

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

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

    <defaultLiveTemplatesProvider implementation="org.jetbrains.plugins.groovy.template.GroovyTemplatesProvider"/>

    <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" 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.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.ExternalAnnotationsLineMarkerProvider"/>
    <codeInsight.gotoSuper language="Groovy"
                           implementationClass="org.jetbrains.plugins.groovy.codeInsight.navigation.actions.GroovyGotoSuperHandler"/>
    <lookup.charFilter implementation="org.jetbrains.plugins.groovy.lang.completion.GroovyReferenceCharFilter"/>
    <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.console.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="com.intellij.codeInsight.completion.UnfocusedNameIdentifier"
                           id="groovyNameIdentifier"/>
    <completion.confidence language="Groovy" implementationClass="org.jetbrains.plugins.groovy.lang.completion.GroovyCompletionConfidence"
                           id="groovyAdvanced" order="after groovyNameIdentifier"/>
    <completion.confidence language="Groovy" implementationClass="com.intellij.codeInsight.completion.UnfocusedComments"
                           id="groovyComments"/>
    <completion.confidence language="Groovy" implementationClass="com.intellij.codeInsight.completion.AlwaysFocusLookup" id="groovyTrue"
                           order="last"/>
    <completion.contributor language="Groovy" implementationClass="org.jetbrains.plugins.groovy.geb.GebPageFieldNameCompletionContributor"/>

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

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

    <pom.declarationSearcher implementation="org.jetbrains.plugins.groovy.spock.SpockPomDeclarationSearcher"/>

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

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

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

    <compileServer.plugin classpath="groovy-jps-plugin.jar"/>

    <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"
                                order="before wordSelectioner"/>
    <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.AccessorMethodReferencesSearcher"/>
    <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"/>
    <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"/>

    <fileTemplateGroup implementation="org.jetbrains.plugins.groovy.actions.GroovyTemplatesFactory"/>

    <attachSourcesProvider implementation="org.jetbrains.plugins.groovy.ivy.IvyAttachSourceProvider"/>

    <projectConfigurable instance="org.jetbrains.plugins.groovy.compiler.GroovyCompilerConfigurable" id="Groovy compiler"
                         displayName="Groovy Compiler" parentId="project.propCompiler"/>

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

    <stubElementTypeHolder class="org.jetbrains.plugins.groovy.lang.parser.GroovyElementTypes"/>
    <!--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"/>

    <antCustomCompiler implementation="org.jetbrains.plugins.groovy.ant.GroovyAntCustomCompilerProvider"/>

    <project.converterProvider implementation="org.jetbrains.plugins.groovy.config.GroovyModuleConverterProvider"/>
    <project.converterProvider implementation="org.jetbrains.plugins.groovy.config.GroovyRunConfigurationConverterProvider"/>

    <iconProvider implementation="org.jetbrains.plugins.groovy.GroovyIconProvider"/>

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

    <psi.referenceContributor implementation="org.jetbrains.plugins.groovy.lang.resolve.providers.GroovyReferenceContributor"/>

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

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

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

    <projectService
        serviceImplementation="org.jetbrains.plugins.groovy.dgm.GroovyExtensionProvider"/>

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

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

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

    <localInspection shortName="GroovyUnusedDeclaration" displayName="Unused declaration"
                     groupPath="Groovy"
                     groupName="Declaration redundancy" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.GroovyUnusedDeclarationInspection" unfair="true"/>

    <localInspection language="Groovy" groupPath="Groovy" shortName="SecondUnsafeCall"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="second.unsafe.call" groupName="Probable bugs" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.secondUnsafeCall.SecondUnsafeCallInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnusedAssignment"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="unused.assignment" groupKey="groovy.dfa.issues" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.unusedDef.UnusedDefInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnusedIncOrDec"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="unused.inc.dec" groupKey="groovy.dfa.issues" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrUnusedIncDecInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyVariableNotAssigned"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="unassigned.access" groupKey="groovy.dfa.issues" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.unassignedVariable.UnassignedVariableAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyMissingReturnStatement"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="no.return.display.name" groupKey="groovy.dfa.issues" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.noReturnMethod.MissingReturnInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="TypeCustomizer"
                     displayName="Type customizer inspection"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     groupKey="other" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.resources.TypeCustomizerInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyAssignabilityCheck" displayName="Incompatible type assignments"
                     groupName="Assignment issues"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignabilityCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyResultOfAssignmentUsed" displayName="Result of assignment used"
                     groupName="Assignment issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyResultOfAssignmentUsedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyAssignmentCanBeOperatorAssignment"
                     displayName="Assignment replaceable with operator assignment"
                     groupName="Assignment issues" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignmentCanBeOperatorAssignmentInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyAssignmentToForLoopParameter"
                     displayName="Assignment to for-loop parameter"
                     groupName="Assignment issues" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignmentToForLoopParameterInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyAssignmentToMethodParameter"
                     displayName="Assignment to method parameter"
                     groupName="Assignment issues" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignmentToMethodParameterInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyNestedAssignment" displayName="Nested assignment"
                     groupName="Assignment issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyNestedAssignmentInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovySillyAssignment" displayName="Silly assignment"
                     groupName="Assignment issues" enabledByDefault="true"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovySillyAssignmentInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUncheckedAssignmentOfMemberOfRawType"
                     displayName="Unchecked assignment from members of raw type"
                     groupName="Assignment issues" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyUncheckedAssignmentOfMemberOfRawTypeInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyContinueOrBreakFromFinallyBlock"
                     displayName="'continue' or 'break' inside 'finally' block"
                     groupName="Error handling" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyContinueOrBreakFromFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GrMethodMayBeStatic"
                     displayName="Method may be static"
                     groupName="Declaration" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.declaration.GrMethodMayBeStaticInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyReturnFromFinallyBlock"
                     displayName="'return' inside 'finally' block" groupName="Error handling"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyReturnFromFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyThrowFromFinallyBlock"
                     displayName="'throw' inside 'finally' block" groupName="Error handling"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyThrowFromFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyEmptyCatchBlock" displayName="Empty 'catch' block"
                     groupName="Error handling" enabledByDefault="false"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyEmptyCatchBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyEmptyFinallyBlock" displayName="Empty 'finally' block"
                     groupName="Error handling"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyEmptyFinallyBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyEmptyTryBlock" displayName="Empty 'try' block"
                     groupName="Error handling" enabledByDefault="false"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyEmptyTryBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnusedCatchParameter" displayName="Unused catch parameter"
                     groupName="Error handling"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.exception.GroovyUnusedCatchParameterInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyBreak" displayName="Break statement" groupName="Control Flow"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyBreakInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyContinue" displayName="Continue statement"
                     groupName="Control Flow" enabledByDefault="false"
                     level="WARNING" implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyContinueInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnreachableStatement" displayName="Unreachable Statement"
                     groupName="Validity issues"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.validity.GroovyUnreachableStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyLoopStatementThatDoesntLoop"
                     displayName="Loop statement that doesn't loop" groupName="Control Flow"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyLoopStatementThatDoesntLoopInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyConditionalWithIdenticalBranches"
                     displayName="Conditional expression with identical branches"
                     groupName="Control Flow" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConditionalWithIdenticalBranchesInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyConditionalCanBeElvis"
                     displayName="Conditional expression can be elvis" groupName="Control Flow"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConditionalCanBeElvisInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyConditionalCanBeConditionalCall"
                     displayName="Conditional expression can be conditional call"
                     groupName="Control Flow" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConditionalCanBeConditionalCallInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyIfStatementWithIdenticalBranches"
                     displayName="If statement with identical branches"
                     groupName="Control Flow" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyIfStatementWithIdenticalBranchesInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyIfStatementWithTooManyBranches"
                     displayName="If statement with too many branches"
                     groupName="Control Flow" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyIfStatementWithTooManyBranchesInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyFallthrough" displayName="Fallthrough in switch statement"
                     groupName="Control Flow"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyFallthroughInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnnecessaryContinue"
                     displayName="Unnecessary 'continue' statement" groupName="Control Flow"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyUnnecessaryContinueInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnnecessaryReturn" displayName="Unnecessary 'return' statement"
                     groupName="Control Flow"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyUnnecessaryReturnInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GrFinalVariableAccess" displayName="Final variable access"
                     groupName="Control Flow"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.finalVar.GrFinalVariableAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovySwitchStatementWithNoDefault"
                     displayName="Switch statement with no default case"
                     groupName="Control Flow" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovySwitchStatementWithNoDefaultInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyReturnFromClosureCanBeImplicit"
                     displayName="'return' statement can be implicit"
                     groupName="Control Flow" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyReturnFromClosureCanBeImplicitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyTrivialConditional"
                     displayName="Redundant conditional expression" groupName="Control Flow"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyTrivialConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyConstantConditional"
                     displayName="Constant conditional expression" groupName="Control Flow"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConstantConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyConstantIfStatement" displayName="Constant if statement"
                     groupName="Control Flow"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyConstantIfStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyTrivialIf" displayName="Redundant 'if' statement"
                     groupName="Control Flow" enabledByDefault="true"
                     level="WARNING" implementationClass="org.jetbrains.plugins.groovy.codeInspection.control.GroovyTrivialIfInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="JavaStylePropertiesInvocation"
                     displayName="Java-style property access"
                     groupName="Style" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.style.JavaStylePropertiesInvocationInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyAccessToStaticFieldLockedOnInstance"
                     displayName="Access to static field locked on instance data"
                     groupName="Threading issues" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyAccessToStaticFieldLockedOnInstanceInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyDoubleCheckedLocking" displayName="Double-checked locking"
                     groupName="Threading issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyDoubleCheckedLockingInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnconditionalWait" displayName="Unconditional 'wait' call"
                     groupName="Threading issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyUnconditionalWaitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyPublicFieldAccessedInSynchronizedContext"
                     displayName="Non-private field accessed in synchronized context" groupName="Threading issues" enabledByDefault="false"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyPublicFieldAccessedInSynchronizedContextInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyBusyWait" displayName="Busy wait" groupName="Threading issues"
                     enabledByDefault="false"
                     level="WARNING" implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyBusyWaitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyEmptySyncBlock" displayName="Empty 'synchronized' block"
                     groupName="Threading issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyEmptySyncBlockInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovySynchronizationOnThis" displayName="Synchronization on 'this'"
                     groupName="Threading issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizationOnThisInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovySynchronizedMethod" displayName="Synchronized method"
                     groupName="Threading issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizedMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyNestedSynchronizedStatement"
                     displayName="Nested 'synchronized' statement"
                     groupName="Threading issues" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyNestedSynchronizedStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyThreadStopSuspendResume"
                     displayName="Call to Thread.stop(), Thread.suspend(), or Thread.resume()"
                     groupName="Threading issues" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyThreadStopSuspendResumeInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovySystemRunFinalizersOnExit"
                     displayName="Call to System.runFinalizersOnExit()"
                     groupName="Threading issues" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySystemRunFinalizersOnExitInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyNotifyWhileNotSynchronized"
                     displayName="'notify()' or 'notifyAll()' while not synced"
                     groupName="Threading issues" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyNotifyWhileNotSynchronizedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyWaitCallNotInLoop" displayName="'wait()' not in loop"
                     groupName="Threading issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyWaitCallNotInLoopInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyWaitWhileNotSynchronized" displayName="'wait()' while not synced"
                     groupName="Threading issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyWaitWhileNotSynchronizedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovySynchronizationOnNonFinalField"
                     displayName="Synchronization on non-final field"
                     groupName="Threading issues" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizationOnNonFinalFieldInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovySynchronizationOnVariableInitializedWithLiteral"
                     displayName="Synchronization on variable initialized with literal" groupName="Threading issues"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovySynchronizationOnVariableInitializedWithLiteralInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUnsynchronizedMethodOverridesSynchronizedMethod"
                     displayName="Unsynchronized method overrides synchronized method" groupName="Threading issues" enabledByDefault="true"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyUnsynchronizedMethodOverridesSynchronizedMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyWhileLoopSpinsOnField" displayName="While loop spins on field"
                     groupName="Threading issues"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.threading.GroovyWhileLoopSpinsOnFieldInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyMethodParameterCount"
                     displayName="Method with too many parameters" groupName="Method Metrics"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyMethodParameterCountInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyOverlyComplexMethod" displayName="Overly complex method"
                     groupName="Method Metrics"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyOverlyComplexMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyOverlyLongMethod" displayName="Overly long method"
                     groupName="Method Metrics" enabledByDefault="false"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyOverlyLongMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyOverlyNestedMethod" displayName="Overly nested method"
                     groupName="Method Metrics"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyOverlyNestedMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyMethodWithMoreThanThreeNegations"
                     displayName="Method with more than three negations"
                     groupName="Method Metrics" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyMethodWithMoreThanThreeNegationsInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyMultipleReturnPointsPerMethod"
                     displayName="Method with multiple return points"
                     groupName="Method Metrics" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.metrics.GroovyMultipleReturnPointsPerMethodInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyNestedSwitch" displayName="Nested switch statement"
                     groupName="Potentially confusing code constructs"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNestedSwitchInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyConditional" displayName="Conditional expression"
                     groupName="Potentially confusing code constructs"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GrFieldAlreadyDefined"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="field.already.defined" groupName="Potentially confusing code constructs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrFieldAlreadyDefinedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="ClashingGetters"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="clashing.getters" groupName="Potentially confusing code constructs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.ClashingGettersInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GrPackage"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="gr.package" groupName="Potentially confusing code constructs" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrPackageInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GrDeprecatedAPIUsage"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="gr.deprecated.api.usage" groupName="Potentially confusing code constructs" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrDeprecatedAPIUsageInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyNestedConditional" displayName="Nested conditional expression"
                     groupName="Potentially confusing code constructs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNestedConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyNegatedConditional" displayName="Negated conditional expression"
                     groupName="Potentially confusing code constructs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNegatedConditionalInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyInArgumentCheck" displayName="Incompatible 'in' argument types"
                     enabledByDefault="true" groupName="Probable bugs" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyInArgumentCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyNegatedIf" displayName="Negated if condition expression"
                     groupName="Potentially confusing code constructs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyNegatedIfInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyResultOfIncrementOrDecrementUsed"
                     displayName="Result of increment or decrement used"
                     groupName="Potentially confusing code constructs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyResultOfIncrementOrDecrementUsedInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" enabledByDefault="true" level="WARNING"
                     shortName="GrReassignedInClosureLocalVar"
                     displayName="Local variable is reassigned in closure or anonymous class"
                     groupName="Potentially confusing code constructs"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GrReassignedInClosureLocalVarInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="UnnecessaryQualifiedReference"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="unnecessary.qualified.reference" groupName="Potentially confusing code constructs" enabledByDefault="true"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.UnnecessaryQualifiedReferenceInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyEmptyStatementBody" displayName="Statement with empty body"
                     groupName="Potentially confusing code constructs" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyEmptyStatementBodyInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyPointlessBoolean"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="pointless.boolean.display.name" groupName="Potentially confusing code constructs" enabledByDefault="true"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyPointlessBooleanInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyPointlessArithmetic"
                     displayName="Pointless arithmetic expression"
                     groupName="Potentially confusing code constructs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyPointlessArithmeticInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyDoubleNegation" displayName="Double negation"
                     groupName="Potentially confusing code constructs"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyDoubleNegationInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyOverlyComplexArithmeticExpression"
                     displayName="Overly complex arithmetic expression"
                     groupName="Potentially confusing code constructs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyOverlyComplexArithmeticExpressionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="ClashingTraitMethods"
                     displayName="Clashing trait methods"
                     groupName="Potentially confusing code constructs" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.ClashingTraitMethodsInspection"/>

    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyOverlyComplexBooleanExpression"
                     displayName="Overly complex boolean expression"
                     groupName="Potentially confusing code constructs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyOverlyComplexBooleanExpressionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyOctalInteger" displayName="Octal integer"
                     groupName="Potentially confusing code constructs"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.GroovyOctalIntegerInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyDuplicateSwitchBranch" displayName="Duplicate switch case"
                     groupName="Validity issues"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.validity.GroovyDuplicateSwitchBranchInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyNonShortCircuitBoolean" displayName="Non short-circuit boolean"
                     groupName="Probable bugs"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyNonShortCircuitBooleanInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyInfiniteLoopStatement" displayName="Infinite loop statement"
                     groupName="Probable bugs"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyInfiniteLoopStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyInfiniteRecursion" displayName="Infinite recursion"
                     groupName="Probable bugs" enabledByDefault="true"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyInfiniteRecursionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyDivideByZero" displayName="Divide by zero"
                     groupName="Probable bugs" enabledByDefault="true"
                     level="WARNING" implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyDivideByZeroInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyResultOfObjectAllocationIgnored"
                     displayName="Result of object allocation ignored"
                     groupName="Probable bugs" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyResultOfObjectAllocationIgnoredInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyAccessibility"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="access.to.inaccessible.element" groupName="Probable bugs" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyAccessibilityInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyConstructorNamedArguments"
                     displayName="Named arguments of constructor call" groupName="Probable bugs"
                     enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyConstructorNamedArgumentsInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyDocCheck" displayName="GroovyDoc issues"
                     groupName="Probable bugs"
                     enabledByDefault="true" level="ERROR"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyDocCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyRangeTypeCheck"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="incorrect.range.argument" groupName="Probable bugs" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyRangeTypeCheckInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="NewInstanceOfSingleton"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="new.instance.of.singleton" groupName="Potentially confusing code constructs" enabledByDefault="true"
                     level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.NewInstanceOfSingletonInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyLabeledStatement"
                     bundle="org.jetbrains.plugins.groovy.codeInspection.GroovyInspectionBundle"
                     key="check.labeled.statement" groupName="Probable bugs" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.bugs.GroovyLabeledStatementInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyClassNamingConvention" displayName="Class naming convention"
                     groupName="Naming Conventions"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyClassNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyInterfaceNamingConvention"
                     displayName="Interface naming convention" groupName="Naming Conventions"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyInterfaceNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyAnnotationNamingConvention"
                     displayName="Annotation naming convention" groupName="Naming Conventions"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyAnnotationNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyEnumerationNamingConvention"
                     displayName="Enumeration naming convention"
                     groupName="Naming Conventions" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyEnumerationNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyLocalVariableNamingConvention"
                     displayName="Local variable naming convention"
                     groupName="Naming Conventions" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyLocalVariableNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyStaticMethodNamingConvention"
                     displayName="Static method naming convention"
                     groupName="Naming Conventions" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyStaticMethodNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyStaticVariableNamingConvention"
                     displayName="Static variable naming convention"
                     groupName="Naming Conventions" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyStaticVariableNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyInstanceMethodNamingConvention"
                     displayName="Instance method naming convention"
                     groupName="Naming Conventions" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyInstanceMethodNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyInstanceVariableNamingConvention"
                     displayName="Instance variable naming convention"
                     groupName="Naming Conventions" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyInstanceVariableNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyConstantNamingConvention"
                     displayName="Constant naming convention" groupName="Naming Conventions"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyConstantNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyParameterNamingConvention"
                     displayName="Method parameter naming convention"
                     groupName="Naming Conventions" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.naming.GroovyParameterNamingConventionInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyMapGetCanBeKeyedAccess"
                     displayName="Call to Map.get can be keyed access"
                     groupName="GPath inspections" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyMapGetCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyMapPutCanBeKeyedAccess"
                     displayName="Call to Map.put can be keyed access"
                     groupName="GPath inspections" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyMapPutCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyListGetCanBeKeyedAccess"
                     displayName="Call to List.get can be keyed access"
                     groupName="GPath inspections" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyListGetCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyListSetCanBeKeyedAccess"
                     displayName="Call to List.set can be keyed access"
                     groupName="GPath inspections" enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.gpath.GroovyListSetCanBeKeyedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovyUntypedAccess" displayName="Access to untyped expression"
                     groupName="Probable bugs"
                     enabledByDefault="false" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.untypedUnresolvedAccess.GroovyUntypedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GrUnresolvedAccess" displayName="Access to unresolved expression"
                     groupName="Probable bugs"
                     enabledByDefault="true" level="WEAK WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.untypedUnresolvedAccess.GrUnresolvedAccessInspection"/>
    <localInspection language="Groovy" groupPath="Groovy" shortName="GroovySingletonAnnotation"
                     displayName="Check '@Singleton' annotation conventions"
                     groupName="Annotations verifying" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.annotator.inspections.GroovySingletonAnnotationInspection"/>

    <localInspection language="Groovy" groupPath="Groovy" shortName="DelegatesTo" displayName="@DelegatesTo inspection"
                     groupName="Annotations verifying" enabledByDefault="true" level="WARNING"
                     implementationClass="org.jetbrains.plugins.groovy.codeInspection.confusing.DelegatesToInspection"/>

    <implicitUsageProvider implementation="org.jetbrains.plugins.groovy.gpp.GppImplicitUsageProvider"/>
    <implicitUsageProvider implementation="org.jetbrains.plugins.groovy.findUsages.GrImplicitUsageProvider"/>

    <!-- control flow -->
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.DemorgansLawIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.SplitIfIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.InvertIfIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.GrRedundantElseIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.FlipIfIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.ReplaceTernaryWithIfElseIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.ReplaceIfWithTernaryIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.SimplifyTernaryOperatorIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.CreateParameterForFieldIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.MergeIfAndIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.ExpandBooleanIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.FlipConjunctionIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.FlipComparisonIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.NegateComparisonIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.MergeElseIfIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.SplitElseIfIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.control.flow</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.control.FlipConditionalIntention</className>
    </intentionAction>

    <!-- closures -->
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.closures</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.closure.MakeClosureCallExplicitIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.closures</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.closure.MakeClosureCallImplicitIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.closures</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.closure.ForToEachIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.closures</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.closure.EachToForIntention</className>
    </intentionAction>
    <!--
    todo make this work
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.closures</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.closure.ConvertClosureArgToItIntention</className>
    </intentionAction>
    -->


    <!-- comments -->
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.comments</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.comments.ChangeToCStyleCommentIntention</className>
    </intentionAction>
    <!--
    todo make this work
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.comments</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.comments.ChangeToEndOfLineCommentIntention</className>
    </intentionAction>
    -->

    <!-- conversions -->
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertJavaStyleArrayIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertIntegerToDecimalIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertIntegerToHexIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertIntegerToOctalIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertIntegerToBinaryIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.IndexingMethodConversionIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.IndexedExpressionConversionIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.strings.ConvertGStringToStringIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.strings.ConvertMultilineStringToSingleLineIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.strings.ConvertToRegexIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.strings.ConvertToDollarSlashRegexIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.strings.GrConvertStringToCharIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.strings.RemoveUnnecessaryEscapeCharactersIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.strings.GrBreakStringOnLineBreaksIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.GrSplitDeclarationIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.RemoveParenthesesFromMethodCallIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.RemoveUnnecessaryBracesInGStringIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertMapToClassIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.strings.ConvertConcatenationToGstringIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.RenameFileWithClassIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.MoveClassToNewFileIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertMethodToClosureIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.strings.ConvertStringToMultilineIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertClosureToMethodIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertSimpleGetterToPropertyIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.GrConvertTypeCastToSafeCastIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.conversions</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.conversions.ConvertJunitAssertionToAssertStatementIntention</className>
    </intentionAction>

    <!-- groovy style -->
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.JavaStylePropertiesInvocationIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.RemoveUnnecessarySemicolonsIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.ImportStaticIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.ImportOnDemandIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.ConvertToGeeseBracesIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.RemoveRedundantClassPropertyIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.ConvertFromGeeseBracesIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.RemoveUnnecessaryReturnIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.AddReturnTypeFix</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.parameterToEntry.ConvertParameterToMapEntryIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.style</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.style.ReplaceAbstractClassInstanceByMapIntention</className>
    </intentionAction>

    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy</categoryKey>
      <className>org.jetbrains.plugins.groovy.grape.GrabDependencies</className>
    </intentionAction>

    <!--declaration-->
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.declaration</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.declaration.GrCreateSubclassAction</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.declaration</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.declaration.GrCreateFieldForParameterIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.declaration</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.declaration.GrSetStrongTypeIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.declaration</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.declaration.GrMakeMemberPublicIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.declaration</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.declaration.GrMakeMemberProtectedIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.declaration</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.declaration.GrMakeMemberPrivateIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.declaration</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.declaration.GrIntroduceLocalVariableIntention</className>
    </intentionAction>

    <!--other-->
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.other</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.other.GrCreateMissingSwitchBranchesIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.other</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.other.GrAliasImportIntention</className>
    </intentionAction>
    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.other</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.other.GrCopyStringConcatenationContentIntention</className>
    </intentionAction>

    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.other</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.other.GrSortMapKeysIntention</className>
    </intentionAction>

    <intentionAction>
      <bundleName>org.jetbrains.plugins.groovy.intentions.GroovyIntentionsBundle</bundleName>
      <categoryKey>intention.category.groovy.declaration</categoryKey>
      <className>org.jetbrains.plugins.groovy.intentions.declaration.GrRemoveExplicitTypeDeclarationIntention</className>
    </intentionAction>

    <projectService
        serviceImplementation="org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicToolWindowWrapper"/>

    <projectService serviceInterface="org.jetbrains.plugins.groovy.griffon.GriffonProjectViewState"
                    serviceImplementation="org.jetbrains.plugins.groovy.griffon.GriffonProjectViewState"/>

    <java.programPatcher implementation="org.jetbrains.plugins.groovy.debugger.GroovyHotSwapper"/>
    <psi.referenceContributor implementation="org.jetbrains.plugins.groovy.gpp.GppReferenceContributor"/>

    <library.presentationProvider implementation="org.jetbrains.plugins.groovy.griffon.GriffonLibraryPresentationProvider"/>
    <moduleBuilder builderClass="org.jetbrains.plugins.groovy.griffon.GriffonModuleBuilder" id="griffonModuleBuilder"/>
    <projectStructureDetector implementation="org.jetbrains.plugins.groovy.griffon.GriffonProjectStructureDetector"
                              order="before groovyDetector"/>
    <programRunner implementation="org.jetbrains.plugins.groovy.griffon.GriffonDebuggerRunner"/>
    <!-- <configurationType implementation="org.jetbrains.plugins.groovy.griffon.GriffonRunConfigurationType"/> -->
    <toolWindow id="Griffon View" anchor="left" secondary="false" icon="JetgroovyIcons.Griffon.GriffonToolWindow"
                factoryClass="org.jetbrains.plugins.groovy.griffon.GriffonToolWindowFactory"
                conditionClass="org.jetbrains.plugins.groovy.griffon.GriffonToolWindowFactory"/>

    <roots.watchedRootsProvider implementation="org.jetbrains.plugins.groovy.mvc.MvcWatchedRootProvider"/>
    <projectService serviceInterface="org.jetbrains.plugins.groovy.mvc.MvcConsole"
                    serviceImplementation="org.jetbrains.plugins.groovy.mvc.MvcConsole"/>
    <selectInTarget implementation="org.jetbrains.plugins.groovy.mvc.projectView.MvcProjectViewSelectInTarget"/>
    <applicationService serviceImplementation="org.jetbrains.plugins.groovy.mvc.MvcRunTargetHistoryService"
                        serviceInterface="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"/>
    <structuralsearch.profile implementation="com.intellij.structuralsearch.GroovyStructuralSearchProfile"/>
    <equivalenceDescriptorProvider implementation="com.intellij.structuralsearch.GroovyEquivalenceDescriptorProvider"/>
  </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" text="Execute Groovy Code"
            description="Execute Groovy code in console">
      <keyboard-shortcut first-keystroke="control ENTER" keymap="$default"/>
    </action>

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

    <action id="Gant.NewScript" class="org.jetbrains.plugins.groovy.gant.NewGantScriptAction"
            text="Gant Script" description="Create new Gant script">
      <add-to-group group-id="NewGroup" anchor="last"/>
    </action>

    <group id="Groovy.Dynamic.Toolbar">
      <action id="Groovy.Dynamic.Remove" class="org.jetbrains.plugins.groovy.annotator.intentions.dynamic.RemoveDynamicAction"
              icon="AllIcons.General.Remove" text="Remove" description="Remove dynamic element"/>
      <separator/>
      <action id="Groovy.Dynamic.ExpandAll" class="org.jetbrains.plugins.groovy.annotator.intentions.dynamic.ExpandAllAction"
              icon="AllIcons.Actions.Expandall" text="Expand all" description="Collapse all"/>
      <action id="Groovy.Dynamic.CollapseAll" class="org.jetbrains.plugins.groovy.annotator.intentions.dynamic.CollapseAllAction"
              icon="AllIcons.Actions.Collapseall" text="Collapse all" description="Collapse all"/>
    </group>


    <action id="ConvertGroovyToJava"
            class="org.jetbrains.plugins.groovy.actions.ConvertToJavaAction"
            text="Convert to Java"
            description="Convert Groovy files to Java">
      <add-to-group group-id="RefactoringMenu"/>
    </action>

    <group id="Internal.Groovy" text="Groovy" popup="true" internal="true">
      <action id="GetPsiTypeAction" class="org.jetbrains.plugins.groovy.actions.GrGetPsiTypeAction"
              text="get PsiType" description=""
              internal="true"/>

      <action id="DumpGroovyControlFlowAction"
              class="org.jetbrains.plugins.groovy.actions.DumpGroovyControlFlowAction"
              text="dump groovy control flow"
              description="" internal="true"/>
      <action id="DumpGroovyStubsAction"
              class="org.jetbrains.plugins.groovy.actions.DumpGroovyStubsAction"
              text="dump groovy stubs"
              description="" internal="true"/>
      <add-to-group group-id="Internal"/>
    </group>

    <action id="ExcludeFromStubGeneration"
            class="org.jetbrains.plugins.groovy.compiler.ExcludeFromStubGenerationAction"
            text="Exclude from stub generation" description="Don't generate Java stubs for this Groovy file on compilation">
      <add-to-group group-id="EditorTabPopupMenu" anchor="after" relative-to-action="RenameJavaFileToGroovyFileAction"/>
    </action>


    <group id="GroovyGenerateGroup1">
      <action id="org.jetbrains.plugins.groovy.actions.generate.constructors.GroovyGenerateConstructorAction"
              class="org.jetbrains.plugins.groovy.actions.generate.constructors.GroovyGenerateConstructorAction"
              text="Constructor" description="Generates constructor"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterAction"
              class="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterAction"
              text="Getter" description="Generates getter"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateSetterAction"
              class="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateSetterAction"
              text="Setter" description="Generates setter"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterSetterAction"
              class="org.jetbrains.plugins.groovy.actions.generate.accessors.GroovyGenerateGetterSetterAction"
              text="Getter and Setter" description="Generates getter"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.equals.GroovyGenerateEqualsAction"
              class="org.jetbrains.plugins.groovy.actions.generate.equals.GroovyGenerateEqualsAction"
              text="equals() and hashCode()" description="Action generates equals and hashCode now"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGenerateMethodMissingAction"
              class="org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGenerateMethodMissingAction"
              text="methodMissing()" description="Action generates propertyMissing()"/>
      <action id="org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGeneratePropertyMissingAction"
              class="org.jetbrains.plugins.groovy.actions.generate.missing.GroovyGeneratePropertyMissingAction"
              text="propertyMissing()" description="Action generates propertyMissing()"/>

      <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"
            text="Generate GroovyDoc..." description="Generating Groovy Documentation"
            icon="JetgroovyIcons.Groovy.GroovyDoc">
      <add-to-group group-id="ToolsMenu" anchor="last"/>
    </action>
    <action id="Groovy.Shell"
            class="org.jetbrains.plugins.groovy.console.GroovyShellAction"
            text="Groovy Shell..." description="Launch Groovy Shell"
            icon="JetgroovyIcons.Groovy.Groovy_16x16">
      <add-to-group group-id="ToolsMenu" anchor="last"/>
    </action>

    <action id="Groovy.Console"
            class="org.jetbrains.plugins.groovy.console.GroovyConsoleAction"
            text="Groovy Console..." description="Launch Groovy Console"
            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"
              text="Change SDK version" description="Change Grails/Griffon SDK version">
      </action>

      <action id="Griffon.UpdateDependencies" class="org.jetbrains.plugins.groovy.griffon.UpdateGriffonSettingsAction"
              text="Synchronize Griffon settings"
              description="Refresh IntelliJ IDEA project structure so that it matches Griffon build settings">
      </action>

      <action id="Mvc.RunTarget" class="org.jetbrains.plugins.groovy.mvc.MvcRunTarget"
              text="Run Target" description="Run arbitrary Grails/Griffon target">
        <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>

  </actions>

  <application-components>
    <component>
      <implementation-class>org.jetbrains.plugins.groovy.gant.GantLoader</implementation-class>
    </component>
    <component>
      <implementation-class>org.jetbrains.plugins.groovy.mvc.MvcPathMacros</implementation-class>
    </component>
    <component>
      <implementation-class>org.jetbrains.plugins.groovy.dsl.DslActivationStatus</implementation-class>
    </component>
  </application-components>

  <project-components>
    <component>
      <implementation-class>org.jetbrains.plugins.groovy.compiler.GroovyCompilerLoader</implementation-class>
    </component>
    <component>
      <implementation-class>org.jetbrains.plugins.groovy.codeInspection.local.GroovyUnusedImportsPassFactory</implementation-class>
    </component>
    <component>
      <implementation-class>org.jetbrains.plugins.groovy.annotator.GrKeywordAndDeclarationHighlightFactory</implementation-class>
    </component>
    <component>
      <implementation-class>org.jetbrains.plugins.groovy.annotator.GrReferenceHighlighterFactory</implementation-class>
    </component>
    <component>
      <interface-class>org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicManager</interface-class>
      <implementation-class>org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicManagerImpl</implementation-class>
    </component>
    <component>
      <implementation-class>org.jetbrains.plugins.groovy.mvc.MvcModuleStructureSynchronizer</implementation-class>
    </component>
  </project-components>
</idea-plugin>