plugins/devkit/src/util/PsiUtil.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.jetbrains.idea.devkit.util;
  18
  19 import com.intellij.psi.*;
  20 import org.jetbrains.annotations.NotNull;
  21 import org.jetbrains.annotations.Nullable;
  22
  23 /**
  24  * @author Konstantin Bulenkov
  25  */
  26 public class PsiUtil {
  27   private PsiUtil() {
  28   }
  29
  30   public static boolean isInstanciatable(@NotNull PsiClass cls) {
  31     final PsiModifierList modifiers = cls.getModifierList();
  32
  33     if (modifiers == null
  34         || cls.isInterface()
  35         || modifiers.hasModifierProperty(PsiModifier.ABSTRACT)
  36         || !isPublicOrStaticInnerClass(cls)) {
  37       return false;
  38     }
  39
  40     final PsiMethod[] constructors = cls.getConstructors();
  41
  42     if (constructors.length == 0) return true;
  43
  44     for (PsiMethod constructor : constructors) {
  45       if (constructor.getParameterList().getParameters().length == 0
  46           && constructor.hasModifierProperty(PsiModifier.PUBLIC)) {
  47         return true;
  48       }
  49     }
  50     return false;
  51   }
  52
  53   public static boolean isPublicOrStaticInnerClass(@NotNull PsiClass cls) {
  54     final PsiModifierList modifiers = cls.getModifierList();
  55     if (modifiers == null) return false;
  56
  57     return modifiers.hasModifierProperty(PsiModifier.PUBLIC) &&
  58            (cls.getParent() instanceof PsiFile || modifiers.hasModifierProperty(PsiModifier.STATIC));
  59   }
  60
  61   public static boolean isOneStatementMethod(@NotNull PsiMethod method) {
  62     final PsiCodeBlock body = method.getBody();
  63     return body != null
  64            && body.getStatements().length == 1
  65            && body.getStatements()[0] instanceof PsiReturnStatement;
  66   }
  67
  68   @Nullable
  69   public static String getReturnedLiteral(PsiMethod method, PsiClass cls) {
  70     if (isOneStatementMethod(method)) {
  71       final PsiExpression value = ((PsiReturnStatement)method.getBody().getStatements()[0]).getReturnValue();
  72       if (value instanceof PsiLiteralExpression) {
  73         final Object str = ((PsiLiteralExpression)value).getValue();
  74         return str == null ? null : str.toString();
  75       } else if (value instanceof PsiMethodCallExpression) {
  76         if (isSimpleClassNameExpression((PsiMethodCallExpression)value)) {
  77           return cls.getName();
  78         }
  79       }
  80     }
  81     return null;
  82   }
  83
  84   private static boolean isSimpleClassNameExpression(PsiMethodCallExpression expr) {
  85     String text = expr.getText();
  86     if (text == null) return false;
  87     text = text.replaceAll(" ", "")
  88                .replaceAll("\n", "")
  89                .replaceAll("\t", "")
  90                .replaceAll("\r", "");
  91     return "getClass().getSimpleName()".equals(text) || "this.getClass().getSimpleName()".equals(text);
  92   }
  93
  94   @Nullable
  95   public static PsiExpression getReturnedExpression(PsiMethod method) {
  96     if (isOneStatementMethod(method)) {
  97       return ((PsiReturnStatement)method.getBody().getStatements()[0]).getReturnValue();
  98     } else {
  99       return null;
 100     }
 101   }
 102 }