Java GroovyFile类代码示例

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@NotNull
@Override
public String getText() {
  String id = getLintId(myId);
  final PsiFile file = PsiTreeUtil.getParentOfType(myElement, PsiFile.class);
  if (file == null) {
    return "";
  } else if (file instanceof XmlFile) {
    return AndroidBundle.message("android.lint.fix.suppress.lint.api.attr", id);
  } else if (file instanceof PsiJavaFile) {
    return AndroidBundle.message("android.lint.fix.suppress.lint.api.annotation", id);
  } else if (file instanceof GroovyFile) {
    return "Suppress: Add //noinspection " + id;
  } else {
    return "";
  }
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@Override
protected RunnerAndConfigurationSettings findExistingByElement(Location location,
                                                               @NotNull List<RunnerAndConfigurationSettings> existingConfigurations,
                                                               ConfigurationContext context) {
  for (RunnerAndConfigurationSettings existingConfiguration : existingConfigurations) {
    final RunConfiguration configuration = existingConfiguration.getConfiguration();
    final GroovyScriptRunConfiguration existing = (GroovyScriptRunConfiguration)configuration;
    final String path = existing.getScriptPath();
    if (path != null) {
      final PsiFile file = location.getPsiElement().getContainingFile();
      if (file instanceof GroovyFile) {
        final VirtualFile vfile = file.getVirtualFile();
        if (vfile != null && FileUtil.toSystemIndependentName(path).equals(ScriptFileUtil.getScriptFilePath(vfile))) {
          if (!((GroovyFile)file).isScript() ||
              GroovyScriptUtil.getScriptType((GroovyFile)file).isConfigurationByLocation(existing, location)) {
            return existingConfiguration;
          }
        }
      }
    }
  }
  return null;
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@NotNull
@Override
protected BaseInspectionVisitor buildVisitor() {
  return new BaseInspectionVisitor() {
    @Override
    public void visitFile(GroovyFileBase file) {
      if (!(file instanceof GroovyFile)) return;

      if (!myCheckScripts && file.isScript()) return;

      String expectedPackage = ResolveUtil.inferExpectedPackageName(file);
      String actual = file.getPackageName();
      if (!expectedPackage.equals(actual)) {

        PsiElement toHighlight = getElementToHighlight((GroovyFile)file);
        if (toHighlight == null) return;

        registerError(toHighlight, "Package name mismatch. Actual: '" + actual + "', expected: '" + expectedPackage+"'",
                      new LocalQuickFix[]{new ChangePackageQuickFix(expectedPackage), GroovyQuickFixFactory.getInstance().createGrMoveToDirFix(actual)},
                      ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
      }
    }
  };
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
private static String generateClassInfo(PsiClass aClass) {
  StringBuilder buffer = new StringBuilder();
  GroovyFile file = (GroovyFile)aClass.getContainingFile();

  String packageName = file.getPackageName();
  if (!packageName.isEmpty()) {
    buffer.append(packageName).append("\n");
  }

  final String classString =
    aClass.isInterface() ? "interface" : aClass instanceof PsiTypeParameter ? "type parameter" : aClass.isEnum() ? "enum" : "class";
  buffer.append(classString).append(" ").append(aClass.getName());

  JavaDocumentationProvider.generateTypeParameters(aClass, buffer);

  JavaDocumentationProvider.writeExtends(aClass, buffer, aClass.getExtendsListTypes());
  JavaDocumentationProvider.writeImplements(aClass, buffer, aClass.getImplementsListTypes());

  return buffer.toString();
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
private static boolean isSemiColonUnnecessaryInCodeBlock(PsiElement semicolon, String text, Project project) {
  final GrStatement prev = getPreviousStatement(semicolon, GrStatement.class);
  final GrStatement next = getNextStatement(semicolon, GrStatement.class);

  if (prev == null || next == null) return true;

  final int startOffset = prev.getTextRange().getStartOffset();
  final int endOffset = next.getTextRange().getEndOffset();

  final int offset = semicolon.getTextRange().getStartOffset();
  final String statementWithoutSemicolon = text.substring(startOffset, offset) + text.substring(offset + 1, endOffset);
  final GroovyFile file = GroovyPsiElementFactory.getInstance(project).createGroovyFile(statementWithoutSemicolon, false, null);
  final GrStatement[] statements = file.getStatements();
  if (statements.length != 2) return false;

  return checkStatementsAreEqual(prev, statements[0]) &&
         checkStatementsAreEqual(next, statements[1]);
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@Override
public void visitNewExpression(GrNewExpression newExpression) {
  super.visitNewExpression(newExpression);
  final GrCodeReferenceElement refElement = newExpression.getReferenceElement();
  if (refElement == null) return;      //new expression is not correct so we shouldn't check it
  
  final PsiElement parent = newExpression.getParent();

  if (parent instanceof GrCodeBlock || parent instanceof GroovyFile) {
    if (parent instanceof GrOpenBlock || parent instanceof GrClosableBlock) {
      if (ControlFlowUtils.openBlockCompletesWithStatement(((GrCodeBlock)parent), newExpression)) {
        return;
      }
    }
    registerError(refElement, newExpression.getArrayCount());
  }
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@Override
public boolean checkApplicability(@NotNull AnnotationHolder holder, @NotNull GrAnnotation annotation) {
  if (GroovyCommonClassNames.GROOVY_TRANSFORM_BASE_SCRIPT.equals(annotation.getQualifiedName())) {
    PsiFile file = annotation.getContainingFile();
    if (file instanceof GroovyFile && !(((GroovyFile)file).isScript())) {
      holder.createErrorAnnotation(annotation, GroovyBundle.message("base.script.annotation.is.allowed.only.inside.scripts"));
      return true;
    }

    PsiElement pparent = annotation.getParent().getParent();
    if (pparent instanceof GrVariableDeclaration) {
      GrTypeElement typeElement = ((GrVariableDeclaration)pparent).getTypeElementGroovy();
      PsiType type = typeElement != null ? typeElement.getType() : null;

      if (!InheritanceUtil.isInheritor(type, GroovyCommonClassNames.GROOVY_LANG_SCRIPT)) {
        String typeText = type != null ? type.getCanonicalText() : CommonClassNames.JAVA_LANG_OBJECT;
        holder.createErrorAnnotation(annotation, GroovyBundle.message("declared.type.0.have.to.extend.script", typeText));
        return true;
      }
    }
  }

  return false;
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
private static boolean suggestImport(PsiElement context) {
  if (context.getParent() != null &&
      !(context.getParent() instanceof PsiErrorElement) &&
      GroovyCompletionUtil.isNewStatement(context, false) &&
      context.getParent().getParent() instanceof GroovyFile) {
    return true;
  }
  final PsiElement leaf = GroovyCompletionUtil.getLeafByOffset(context.getTextRange().getStartOffset() - 1, context);
  if (leaf != null) {
    PsiElement parent = leaf.getParent();
    if (parent instanceof GroovyFile) {
      return GroovyCompletionUtil.isNewStatement(context, false);
    }
  }
  return context.getTextRange().getStartOffset() == 0 && !(context instanceof OuterLanguageElement);
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@Override
public ItemPresentation getPresentation(@NotNull final GroovyFile file) {
  return new ItemPresentation() {
    @Override
    public String getPresentableText() {
      return GroovyBundle.message("groovy.file.0", file.getName());
    }

    @Override
    public String getLocationString() {
      PsiDirectory directory = file.getContainingDirectory();
      return ItemPresentationProviders.getItemPresentation(directory).getPresentableText();
    }

    @Override
    public Icon getIcon(boolean unused) {
      return file.getIcon(Iconable.ICON_FLAG_VISIBILITY | Iconable.ICON_FLAG_READ_STATUS);
    }
  };
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@Nullable
@Override
protected PsiElement checkLocalScope() {
  final GrVariable variable = getVariable();
  if (variable instanceof PsiField) {
    return ((PsiField)getVariable()).getContainingClass();
  }
  else {
    final PsiFile file = variable.getContainingFile();
    if (file instanceof GroovyFile) {
      return ((GroovyFile)file).getScriptClass();
    }
    else {
      return null;
    }
  }
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@Nullable
private GroovyScriptRunner findConfiguration() {
  final VirtualFile scriptFile = getScriptFile();
  if (scriptFile == null) {
    return null;
  }

  final PsiFile psiFile = PsiManager.getInstance(getProject()).findFile(scriptFile);
  if (!(psiFile instanceof GroovyFile)) {
    return null;
  }
  if (!((GroovyFile)psiFile).isScript()) {
    return new DefaultGroovyScriptRunner();
  }

  return GroovyScriptUtil.getScriptType((GroovyFile)psiFile).getRunner();
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
private static void setPackageDefinition(GroovyFile file, GroovyFile newFile, String newPackageName) {
  String modifiersText = null;

  final GrPackageDefinition packageDefinition = file.getPackageDefinition();
  if (packageDefinition != null) {
    final PsiModifierList modifierList = packageDefinition.getModifierList();
    if (modifierList != null) {
      modifiersText = modifierList.getText().trim();
    }
  }

  if (modifiersText != null && !modifiersText.isEmpty()) {
    final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(file.getProject());
    final GrPackageDefinition newPackageDefinition = (GrPackageDefinition)factory.createTopElementFromText(modifiersText + " package " + newPackageName);
    newFile.setPackage(newPackageDefinition);
  }
  else {
    newFile.setPackageName(newPackageName);
  }
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@Override
protected void processIntention(@NotNull PsiElement element, Project project, Editor editor) throws IncorrectOperationException {
  if (!(element instanceof GrReferenceElement)) return;
  final GrReferenceElement ref = (GrReferenceElement)element;
  final PsiElement resolved = ref.resolve();
  if (!(resolved instanceof PsiClass)) return;

  final String qname = ((PsiClass)resolved).getQualifiedName();

  final GrImportStatement importStatement =
    GroovyPsiElementFactory.getInstance(project).createImportStatementFromText(qname, true, true, null);

  final PsiFile containingFile = element.getContainingFile();
  if (!(containingFile instanceof GroovyFile)) return;
  ((GroovyFile)containingFile).addImport(importStatement);

  for (PsiReference reference : ReferencesSearch.search(resolved, new LocalSearchScope(containingFile))) {
    final PsiElement refElement = reference.getElement();
    if (refElement == null) continue;
    final PsiElement parent = refElement.getParent();
    if (parent instanceof GrQualifiedReference<?>) {
      org.jetbrains.plugins.groovy.codeStyle.GrReferenceAdjuster.shortenReference((GrQualifiedReference<?>)parent);
    }
  }
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
public static Set<LightMethodBuilder> getAntTasks(PsiElement place) {
  final PsiFile file = place.getContainingFile();
  if (!(file instanceof GroovyFile)) {
    return Collections.emptySet();
  }

  return CachedValuesManager.getManager(file.getProject()).getCachedValue(file, GANT_METHODS, new CachedValueProvider<Set<LightMethodBuilder>>() {
    @Override
    public Result<Set<LightMethodBuilder>> compute() {
      Map<String, Class> antObjects = getAntObjects((GroovyFile)file);

      final Set<LightMethodBuilder> methods = new HashSet<LightMethodBuilder>();

      final Project project = file.getProject();
      final PsiType closureType = TypesUtil.createType(GroovyCommonClassNames.GROOVY_LANG_CLOSURE, file);
      final PsiClassType stringType = TypesUtil.createType(CommonClassNames.JAVA_LANG_STRING, file);

      for (String name : antObjects.keySet()) {
        methods.add(new AntBuilderMethod(file, name, closureType, antObjects.get(name), stringType));
      }
      return Result.create(methods, PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT, ProjectRootManager.getInstance(project));
    }
  }, false);
}
 

import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; //导入依赖的package包/类
@Nullable
public static PsiClass getRunningClass(@Nullable PsiElement element) {
  if (element == null) return null;

  final PsiFile file = element.getContainingFile();
  if (!(file instanceof GroovyFile)) return null;

  for (PsiClass clazz = PsiTreeUtil.getParentOfType(element, PsiClass.class);
       clazz != null;
       clazz = PsiTreeUtil.getParentOfType(clazz, PsiClass.class)) {
    if (canBeRunByGroovy(clazz)) return clazz;
  }

  if (((GroovyFile)file).isScript()) return ((GroovyFile)file).getScriptClass();

  final PsiClass[] classes = ((GroovyFile)file).getClasses();
  if (classes.length > 0) {
    return classes[0];
  }

  return null;
}