Java PsiVariable.getName方法代码示例

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
@Override
public void visitVariable(PsiVariable variable) {
  super.visitVariable(variable);
  if (!PsiType.BOOLEAN.equals(variable.getType())) {
    return;
  }
  final String name = variable.getName();
  final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(variable.getProject());
  final String prefix = codeStyleManager.getPrefixByVariableKind(codeStyleManager.getVariableKind(variable));
  for (final String negativeName : NEGATIVE_NAMES) {
    if (isNegativelyNamed(name, negativeName) || !prefix.isEmpty() && isNegativelyNamed(name, prefix + negativeName)) {
      registerVariableError(variable, variable);
      break;
    }
  }
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
private boolean validateSingular(@NotNull PsiClass psiClass, @NotNull ProblemBuilder problemBuilder) {
  boolean result = true;

  final AccessorsInfo accessorsInfo = AccessorsInfo.build(psiClass);
  final Collection<PsiField> builderFields = getBuilderFields(psiClass, Collections.<PsiField>emptySet(), accessorsInfo);
  for (PsiVariable builderVariable : builderFields) {
    final PsiAnnotation singularAnnotation = PsiAnnotationSearchUtil.findAnnotation(builderVariable, Singular.class);
    if (null != singularAnnotation) {
      final String qualifiedName = PsiTypeUtil.getQualifiedName(builderVariable.getType());
      if (SingularHandlerFactory.isInvalidSingularType(qualifiedName)) {
        problemBuilder.addError("Lombok does not know how to create the singular-form builder methods for type '%s'; " +
          "they won't be generated.", qualifiedName != null ? qualifiedName : builderVariable.getType().getCanonicalText());
        result = false;
      }

      final String variableName = builderVariable.getName();
      if (!AbstractSingularHandler.validateSingularName(singularAnnotation, accessorsInfo.removePrefix(variableName))) {
        problemBuilder.addError("Can't singularize this name: \"%s\"; please specify the singular explicitly (i.e. @Singular(\"sheep\"))", variableName);
        result = false;
      }
    }
  }
  return result;
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
/** Always return true since we wanna get all vars in scope */
@Override
public boolean execute(@NotNull PsiElement pe, @NotNull ResolveState state){
  if(pe instanceof PsiVariable){
    final PsiVariable pvar = (PsiVariable)pe;
    final String pvar_name = pvar.getName();
    if(pvar_name.startsWith(myPrefix)){
      if(!myStaticSensitiveFlag || (!myStaticScopeFlag || pvar.hasModifierProperty(PsiModifier.STATIC))){
        myResultList.add(pvar);
      }
    }
  }

  return true;
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
@Override
public void visitVariable(@NotNull PsiVariable variable) {
  final String name = variable.getName();
  if (nameSet.contains(name)) {
    registerVariableError(variable);
  }
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
@Override
public void visitVariable(@NotNull PsiVariable variable) {
  super.visitVariable(variable);
  final String name = variable.getName();
  if (name == null) {
    return;
  }
  if (name.indexOf((int)'$') < 0) {
    return;
  }
  registerVariableError(variable);
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
/** Always return true since we wanna get all vars in scope */
@Override
public boolean execute(@NotNull PsiElement pe, ResolveState state){
  if(pe instanceof PsiVariable){
    final PsiVariable pvar = (PsiVariable)pe;
    final String pvar_name = pvar.getName();
    if(pvar_name.startsWith(myPrefix)){
      if(!myStaticSensitiveFlag || (!myStaticScopeFlag || pvar.hasModifierProperty(PsiModifier.STATIC))){
        myResultList.add(pvar);
      }
    }
  }

  return true;
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
@Override
public void prepareRenaming(PsiElement element, String newName, Map<PsiElement, String> allRenames) {
  final PsiClass topLevelClass = PsiUtil.getTopLevelClass(element);
  if (topLevelClass == null) {
    return;
  }

  final PsiVariable psiVariable = (PsiVariable) element;
  final String oldName = psiVariable.getName();

  final BeanBindingMetaData dataBindingMetaData = DataBindUtil.getDataBindingMetaData(topLevelClass);
  if (dataBindingMetaData == null) {
    return;
  }
  final Map<String, PropertyInfo> allProperties
      = DataBindUtil.getAllProperties(dataBindingMetaData.getBoundClass(), "");

  final PropertyInfo propertyInfo = allProperties.get(oldName);
  if (propertyInfo == null) {
    return;
  }

  final PsiField associatedField = propertyInfo.getAssociatedField();
  if (associatedField == null) {
    return;
  }

  super.prepareRenaming(associatedField, newName, allRenames);
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
@Override
public void prepareRenaming(PsiElement element, String newName, Map<PsiElement, String> allRenames) {
  final PsiClass topLevelClass = PsiUtil.getTopLevelClass(element);
  if (topLevelClass == null) {
    return;
  }

  final PsiVariable psiVariable = (PsiVariable) element;
  final String oldName = psiVariable.getName();

  final TemplateMetaData templateMetaData = TemplateUtil.getTemplateMetaData(topLevelClass);

  final Multimap<String, TemplateDataField> dataFields = templateMetaData.getAllDataFieldsInTemplate(false);
  final Collection<TemplateDataField> dataField = dataFields.get(oldName);

  if (dataField.size() != 1) {
    return;
  }

  final XmlAttribute dataFieldAttribute = dataField.iterator().next().getDataFieldAttribute();
  if (dataFieldAttribute != null && dataFieldAttribute.getValueElement() != null) {
    FakeNamedPsi fakeNamedPsi = new FakeNamedPsi(dataFieldAttribute) {
      @Override
      public PsiElement setName(@NonNls @NotNull String name) throws IncorrectOperationException {
        dataFieldAttribute.setValue(name);
        return dataFieldAttribute;
      }

      @Override
      public String getName() {
        return dataFieldAttribute.getValue();
      }
    };

    allRenames.put(fakeNamedPsi, newName);
  }
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
@Nullable
private static Boolean computeJavaLangBooleanFieldReference(final PsiVariable variable)
{
	if(!(variable instanceof PsiField))
	{
		return null;
	}
	PsiClass psiClass = ((PsiField) variable).getContainingClass();
	if(psiClass == null || !CommonClassNames.JAVA_LANG_BOOLEAN.equals(psiClass.getQualifiedName()))
	{
		return null;
	}
	@NonNls String name = variable.getName();
	return "TRUE".equals(name) ? Boolean.TRUE : "FALSE".equals(name) ? Boolean.FALSE : null;
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
@Override
protected boolean check(PsiVariable var, ResolveState state) {
  String name = var.getName();
  return name != null && name.equals(myVariable.getName()) && !var.equals(myVariable);
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
public VariableSubLookupElement(final PsiVariable variable) {
  myVarName = variable.getName();
}
 

import com.intellij.psi.PsiVariable; //导入方法依赖的package包/类
public VariableTypeFix(@NotNull PsiVariable variable, PsiType toReturn)
{
	super(variable);
	myReturnType = GenericsUtil.getVariableTypeByExpressionType(toReturn);
	myName = variable.getName();
}