Examples with GroovyFile org.jetbrains.plugins.groovy.lang.psi.GroovyFile used on opensource projects

Example 61 with GroovyFile

use of org.jetbrains.plugins.groovy.lang.psi.GroovyFile in project intellij-community by JetBrains.

the class GradlePositionManager method getRuntimeScriptName.

@NotNull
public String getRuntimeScriptName(@NotNull GroovyFile groovyFile) {
    VirtualFile virtualFile = groovyFile.getVirtualFile();
    if (virtualFile == null)
        return "";
    final Module module = ModuleUtilCore.findModuleForPsiElement(groovyFile);
    if (module == null) {
        return "";
    }
    final File scriptFile = VfsUtilCore.virtualToIoFile(virtualFile);
    final String className = CachedValuesManager.getManager(module.getProject()).getCachedValue(module, GRADLE_CLASS_NAME, new ScriptSourceMapCalculator(module), false).get(scriptFile);
    return className == null ? "" : className;
}

Example 62 with GroovyFile

use of org.jetbrains.plugins.groovy.lang.psi.GroovyFile in project intellij-community by JetBrains.

the class CreateClassFix method createClassFixAction.

public static IntentionAction createClassFixAction(final GrReferenceElement refElement, GrCreateClassKind type) {
    return new CreateClassActionBase(type, refElement) {

        @Override
        protected void processIntention(@NotNull PsiElement element, @NotNull Project project, Editor editor) throws IncorrectOperationException {
            final PsiFile file = element.getContainingFile();
            if (!(file instanceof GroovyFileBase))
                return;
            GroovyFileBase groovyFile = (GroovyFileBase) file;
            PsiElement qualifier = myRefElement.getQualifier();
            if (qualifier == null || qualifier instanceof GrReferenceElement && ((GrReferenceElement) qualifier).resolve() instanceof PsiPackage) {
                createTopLevelClass(project, groovyFile);
            } else {
                createInnerClass(project, editor, qualifier);
            }
        }

        private void createInnerClass(Project project, final Editor editor, PsiElement qualifier) {
            PsiElement resolved = resolveQualifier(qualifier);
            if (!(resolved instanceof PsiClass))
                return;
            JVMElementFactory factory = JVMElementFactories.getFactory(resolved.getLanguage(), project);
            if (factory == null)
                return;
            String name = myRefElement.getReferenceName();
            PsiClass template = createTemplate(factory, name);
            if (template == null) {
                ApplicationManager.getApplication().invokeLater(() -> {
                    if (editor != null && editor.getComponent().isDisplayable()) {
                        HintManager.getInstance().showErrorHint(editor, GroovyIntentionsBundle.message("cannot.create.class"));
                    }
                });
                return;
            }
            if (!FileModificationService.getInstance().preparePsiElementForWrite(resolved))
                return;
            WriteAction.run(() -> {
                PsiClass added = (PsiClass) resolved.add(template);
                PsiModifierList modifierList = added.getModifierList();
                if (modifierList != null) {
                    modifierList.setModifierProperty(PsiModifier.STATIC, true);
                }
                IntentionUtils.positionCursor(project, added.getContainingFile(), added);
            });
        }

        @Nullable
        private PsiElement resolveQualifier(@NotNull PsiElement qualifier) {
            if (qualifier instanceof GrCodeReferenceElement) {
                return ((GrCodeReferenceElement) qualifier).resolve();
            } else if (qualifier instanceof GrExpression) {
                PsiType type = ((GrExpression) qualifier).getType();
                if (type instanceof PsiClassType) {
                    return ((PsiClassType) type).resolve();
                } else if (qualifier instanceof GrReferenceExpression) {
                    final PsiElement resolved = ((GrReferenceExpression) qualifier).resolve();
                    if (resolved instanceof PsiClass || resolved instanceof PsiPackage) {
                        return resolved;
                    }
                }
            }
            return null;
        }

        @Nullable
        private PsiClass createTemplate(JVMElementFactory factory, String name) {
            switch(getType()) {
                case ENUM:
                    return factory.createEnum(name);
                case TRAIT:
                    if (factory instanceof GroovyPsiElementFactory) {
                        return ((GroovyPsiElementFactory) factory).createTrait(name);
                    } else {
                        return null;
                    }
                case CLASS:
                    return factory.createClass(name);
                case INTERFACE:
                    return factory.createInterface(name);
                case ANNOTATION:
                    return factory.createAnnotationType(name);
                default:
                    return null;
            }
        }

        private void createTopLevelClass(@NotNull Project project, @NotNull GroovyFileBase file) {
            final String pack = getPackage(file);
            final PsiManager manager = PsiManager.getInstance(project);
            final String name = myRefElement.getReferenceName();
            assert name != null;
            final Module module = ModuleUtilCore.findModuleForPsiElement(file);
            PsiDirectory targetDirectory = getTargetDirectory(project, pack, name, module, getText());
            if (targetDirectory == null)
                return;
            String templateName = getTemplateName(getType());
            final PsiClass targetClass = createClassByType(targetDirectory, name, manager, myRefElement, templateName, true);
            if (targetClass == null)
                return;
            bindRef(targetClass, myRefElement);
            IntentionUtils.positionCursor(project, targetClass.getContainingFile(), targetClass);
        }

        @NotNull
        private String getPackage(@NotNull PsiClassOwner file) {
            final PsiElement qualifier = myRefElement.getQualifier();
            if (qualifier instanceof GrReferenceElement) {
                final PsiElement resolved = ((GrReferenceElement) qualifier).resolve();
                if (resolved instanceof PsiPackage) {
                    return ((PsiPackage) resolved).getQualifiedName();
                }
            }
            return file instanceof GroovyFile ? file.getPackageName() : "";
        }

        @Override
        public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
            if (!super.isAvailable(project, editor, file))
                return false;
            final PsiElement qualifier = myRefElement.getQualifier();
            if (qualifier != null && resolveQualifier(qualifier) == null) {
                return false;
            }
            return true;
        }
    };
}

Example 63 with GroovyFile

use of org.jetbrains.plugins.groovy.lang.psi.GroovyFile in project intellij-community by JetBrains.

the class CreateClassFix method createClassFromNewAction.

public static IntentionAction createClassFromNewAction(final GrNewExpression expression) {
    return new CreateClassActionBase(GrCreateClassKind.CLASS, expression.getReferenceElement()) {

        @Override
        protected void processIntention(@NotNull PsiElement element, @NotNull Project project, Editor editor) throws IncorrectOperationException {
            final PsiFile file = element.getContainingFile();
            if (!(file instanceof GroovyFileBase))
                return;
            GroovyFileBase groovyFile = (GroovyFileBase) file;
            final PsiManager manager = myRefElement.getManager();
            final String qualifier;
            final String name;
            final Module module;
            final AccessToken accessToken = ReadAction.start();
            try {
                qualifier = groovyFile instanceof GroovyFile ? groovyFile.getPackageName() : "";
                name = myRefElement.getReferenceName();
                assert name != null;
                module = ModuleUtilCore.findModuleForPsiElement(file);
            } finally {
                accessToken.finish();
            }
            PsiDirectory targetDirectory = getTargetDirectory(project, qualifier, name, module, getText());
            if (targetDirectory == null)
                return;
            final GrTypeDefinition targetClass = createClassByType(targetDirectory, name, manager, myRefElement, GroovyTemplates.GROOVY_CLASS, true);
            if (targetClass == null)
                return;
            PsiType[] argTypes = getArgTypes(myRefElement);
            if (argTypes != null && argTypes.length > 0) {
                generateConstructor(myRefElement, name, argTypes, targetClass, project);
                bindRef(targetClass, myRefElement);
            } else {
                bindRef(targetClass, myRefElement);
                IntentionUtils.positionCursor(project, targetClass.getContainingFile(), targetClass);
            }
        }
    };
}

Example 64 with GroovyFile

use of org.jetbrains.plugins.groovy.lang.psi.GroovyFile in project intellij-community by JetBrains.

the class GroovyOptimizeImportsFix method containsErrorsPreventingOptimize.

private static boolean containsErrorsPreventingOptimize(GroovyFile myFile, Document myDocument) {
    // ignore unresolved imports errors
    final TextRange ignoreRange;
    final GrImportStatement[] imports = myFile.getImportStatements();
    if (imports.length != 0) {
        final int start = imports[0].getTextRange().getStartOffset();
        final int end = imports[imports.length - 1].getTextRange().getEndOffset();
        ignoreRange = new TextRange(start, end);
    } else {
        ignoreRange = TextRange.EMPTY_RANGE;
    }
    return !DaemonCodeAnalyzerEx.processHighlights(myDocument, myFile.getProject(), HighlightSeverity.ERROR, 0, myDocument.getTextLength(), error -> {
        int infoStart = error.getActualStartOffset();
        int infoEnd = error.getActualEndOffset();
        return ignoreRange.containsRange(infoStart, infoEnd) && error.type.equals(HighlightInfoType.WRONG_REF);
    });
}

Example 65 with GroovyFile

use of org.jetbrains.plugins.groovy.lang.psi.GroovyFile in project intellij-community by JetBrains.

the class GrMoveToDirFix method doFix.

@Override
protected void doFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) throws IncorrectOperationException {
    PsiFile file = descriptor.getPsiElement().getContainingFile();
    if (!(file instanceof GroovyFile))
        return;
    VirtualFile vfile = file.getVirtualFile();
    if (vfile == null)
        return;
    final Module module = ModuleUtilCore.findModuleForFile(vfile, project);
    if (module == null)
        return;
    final String packageName = ((GroovyFile) file).getPackageName();
    PsiDirectory directory = PackageUtil.findOrCreateDirectoryForPackage(module, packageName, null, true);
    if (directory == null)
        return;
    String error = RefactoringMessageUtil.checkCanCreateFile(directory, file.getName());
    if (error != null) {
        Messages.showMessageDialog(project, error, CommonBundle.getErrorTitle(), Messages.getErrorIcon());
        return;
    }
    new MoveFilesOrDirectoriesProcessor(project, new PsiElement[] { file }, directory, false, false, false, null, null).run();
}