consulo.annotation.access.RequiredReadAction Java Examples

@Nonnull
@RequiredReadAction
private static List<DotNetTypeDeclaration> collectAllTypes(@Nonnull PsiElement place)
{
	List<DotNetTypeDeclaration> typeDeclarations = new SmartList<>();
	if(place instanceof CSharpTypeDeclaration)
	{
		typeDeclarations.add((DotNetTypeDeclaration) place);
	}
	PsiElement type = place;
	while((type = PsiTreeUtil.getContextOfType(type, DotNetTypeDeclaration.class)) != null)
	{
		typeDeclarations.add((DotNetTypeDeclaration) type);
	}
	return typeDeclarations;
}
 

@RequiredReadAction
@Nonnull
@Override
public List<? extends HighlightInfoFactory> check(@Nonnull CSharpLanguageVersion languageVersion, @Nonnull CSharpHighlightContext highlightContext, @Nonnull DotNetTypeDeclaration element)
{
	DotNetModifierList modifierList = element.getModifierList();
	if(modifierList == null)
	{
		return super.check(languageVersion, highlightContext, element);
	}
	PsiElement sealedModifierElement = modifierList.getModifierElement(CSharpModifier.SEALED);
	PsiElement staticModifierElement = modifierList.getModifierElement(CSharpModifier.STATIC);
	if(sealedModifierElement != null && staticModifierElement != null)
	{
		List<HighlightInfoFactory> list = new ArrayList<HighlightInfoFactory>(2);
		String name = formatElement(element);
		list.add(newBuilder(sealedModifierElement, name).addQuickFix(new RemoveModifierFix(DotNetModifier.SEALED, element)));
		list.add(newBuilder(staticModifierElement, name).addQuickFix(new RemoveModifierFix(DotNetModifier.STATIC, element)));
		return list;
	}
	return super.check(languageVersion, highlightContext, element);
}
 

@RequiredReadAction
private String buildQualifiedName()
{
	String parentQualifiedName = null;
	PsiElement parent = getParent();
	if(parent instanceof DotNetNamespaceDeclaration)
	{
		parentQualifiedName = ((DotNetNamespaceDeclaration) parent).getPresentableQName();
	}

	String text = getReferenceText();
	if(!StringUtil.isEmpty(parentQualifiedName))
	{
		return parentQualifiedName + "." + text;
	}
	return text;
}
 

@Nullable
@RequiredReadAction
public static Module findModuleByPsiDirectory(final PsiDirectory directory)
{
	LightVirtualFile l = new LightVirtualFile("test.cs", CSharpFileType.INSTANCE, "")
	{
		@Override
		public VirtualFile getParent()
		{
			return directory.getVirtualFile();
		}

		@Nonnull
		@Override
		public VirtualFileSystem getFileSystem()
		{
			return LocalFileSystem.getInstance();
		}
	};
	return CreateFileFromTemplateAction.ModuleResolver.EP_NAME.composite().resolveModule(directory, CSharpFileType.INSTANCE);
}
 

@Nonnull
@RequiredReadAction
public static DotNetTypeRef resolveTypeForParameter(CSharpLambdaExpressionImpl target, int parameterIndex)
{
	CSharpLambdaResolveResult leftTypeRef = resolveLeftLambdaTypeRef(target);
	if(leftTypeRef == null)
	{
		return DotNetTypeRef.ERROR_TYPE;
	}

	if(leftTypeRef == CSharpUndefinedLambdaResolveResult.INSTANCE)
	{
		return DotNetTypeRef.UNKNOWN_TYPE;
	}
	DotNetTypeRef[] leftTypeParameters = leftTypeRef.getParameterTypeRefs();
	DotNetTypeRef typeRef = ArrayUtil2.safeGet(leftTypeParameters, parameterIndex);
	return ObjectUtil.notNull(typeRef, DotNetTypeRef.ERROR_TYPE);
}
 

@RequiredReadAction
@Nullable
@Override
public CSharpElementGroup<CSharpMethodDeclaration> findExtensionMethodGroupByName(@Nonnull String name)
{
	Map<String, CSharpElementGroup<PsiElement>> map = myOtherCollectorValue.getValue().toMap();
	if(map == null)
	{
		return null;
	}
	CSharpElementGroup<PsiElement> elementGroup = map.get(name);
	if(elementGroup == null)
	{
		return null;
	}

	return filterElementGroupToExtensionGroup(elementGroup);
}
 

@RequiredReadAction
private static void addIndexMethodWithType(String parameterQName, CSharpLightTypeDeclarationBuilder builder, PsiElement scope, int dimensions, DotNetTypeRef innerType)
{
	int parameterCount = dimensions + 1;

	CSharpLightIndexMethodDeclarationBuilder methodDeclarationBuilder = new CSharpLightIndexMethodDeclarationBuilder(builder.getProject(), dimensions);
	methodDeclarationBuilder.addModifier(DotNetModifier.PUBLIC);

	for(int i = 0; i < parameterCount; i++)
	{
		CSharpLightParameterBuilder parameter = new CSharpLightParameterBuilder(scope);
		parameter.withName("index" + i);
		parameter.withTypeRef(new CSharpTypeRefByQName(scope, parameterQName));

		methodDeclarationBuilder.addParameter(parameter);
	}

	methodDeclarationBuilder.withReturnType(innerType);

	builder.addMember(methodDeclarationBuilder);
}
 

@Nonnull
@Override
@RequiredReadAction
public String getDescriptiveName(@Nonnull PsiElement element)
{
	if(element instanceof CSharpPreprocessorVariable)
	{
		return ((CSharpPreprocessorVariable) element).getName();
	}
	if(element instanceof DotNetNamedElement)
	{
		String name = ((DotNetNamedElement) element).getName();
		return name == null ? "null" : name;
	}
	if(element instanceof CSharpLocalVariableDeclarationStatement)
	{
		return StringUtil.join(((CSharpLocalVariableDeclarationStatement) element).getVariables(), PsiNamedElement::getName, ", ");
	}
	return debugText("getDescriptiveName", element);
}
 

@RequiredReadAction
@Nullable
@Override
public HighlightInfoFactory checkImpl(@Nonnull CSharpLanguageVersion languageVersion, @Nonnull CSharpHighlightContext highlightContext, @Nonnull CSharpAwaitExpressionImpl element)
{
	if(languageVersion.isAtLeast(CSharpLanguageVersion._6_0))
	{
		return null;
	}
	CSharpCatchStatementImpl catchStatement = PsiTreeUtil.getParentOfType(element, CSharpCatchStatementImpl.class);
	if(catchStatement != null)
	{
		return newBuilder(element.getAwaitKeywordElement(), "await");
	}
	return null;
}
 

@RequiredReadAction
@Nullable
@Override
public String getVarName()
{
	PsiElement nameIdentifier = getVarElement();
	return nameIdentifier != null ? nameIdentifier.getText() : null;
}
 

@RequiredReadAction
@Override
public CSharpReferenceExpressionStub createStub(@Nonnull CSharpReferenceExpression psi, StubElement parentStub)
{
	String referenceName = psi.getReferenceNameWithAt();
	CSharpReferenceExpression.ResolveToKind kind = psi.kind();
	boolean global = psi.isGlobalElement();
	CSharpReferenceExpression.AccessType memberAccessType = psi.getMemberAccessType();
	return new CSharpReferenceExpressionStub(parentStub, this, referenceName, kind.ordinal(), memberAccessType.ordinal(), global);
}
 

@Nullable
@Override
@RequiredReadAction
public String getElementDescription(@Nonnull PsiElement element, @Nonnull ElementDescriptionLocation location)
{
	if(location == UsageViewShortNameLocation.INSTANCE && element instanceof CSharpNamedElement)
	{
		return ((CSharpNamedElement) element).getNameWithAt();
	}
	return null;
}
 

@Nonnull
@RequiredReadAction
public static List<StubBlock> buildBlocks(PsiElement qualifiedElement, boolean compiled)
{
	CSharpStubBuilderVisitor visitor = new CSharpStubBuilderVisitor(compiled);
	qualifiedElement.accept(visitor);
	return visitor.getBlocks();
}
 

@Nonnull
@RequiredReadAction
public DotNetTypeRef toTypeRefForInference()
{
	// recursion when child lambda reference to parameter from parent lambda
	DotNetTypeRef returnType = RecursionManager.doPreventingRecursion("C# lambda return type", false, this::findPossibleReturnTypeRef);
	if(returnType == null)
	{
		returnType = DotNetTypeRef.ERROR_TYPE;
	}
	return new CSharpLambdaTypeRef(this, null, getParameterInfos(true), returnType);
}
 

@RequiredReadAction
@Nonnull
@Override
public DotNetTypeRef toTypeRefImpl(boolean resolveFromParent)
{
	return new CSharpTypeRefByQName(this, DotNetTypes.System.Boolean);
}
 

@RequiredReadAction
@Override
@Nonnull
public PsiElement getQuestElement()
{
	return findNotNullChildByType(CSharpTokens.QUEST);
}
 

@Nonnull
@Override
@RequiredReadAction
public DotNetTypeRef fun(CSharpTypeElementImpl typeElement)
{
	return typeElement.toTypeRefImpl();
}
 

@RequiredReadAction
private static boolean hasAttribute(DotNetModifierList modifierList, String qName)
{
	for(DotNetAttribute attribute : modifierList.getAttributes())
	{
		DotNetTypeDeclaration typeDeclaration = attribute.resolveToType();
		if(typeDeclaration != null && Comparing.equal(typeDeclaration.getPresentableQName(), qName))
		{
			return true;
		}
	}
	return false;
}
 

@RequiredReadAction
private boolean isValidTypeRef(DotNetTypeRef typeRef)
{
	DotNetTypeResolveResult typeResolveResult = typeRef.resolve();
	PsiElement resolvedElement = typeResolveResult.getElement();

	if(resolvedElement instanceof CSharpTypeDeclaration)
	{
		CSharpTypeDeclaration typeDeclaration = (CSharpTypeDeclaration) resolvedElement;
		if(typeDeclaration.isEnum())
		{
			return true;
		}
		String vmQName = typeDeclaration.getVmQName();
		if(ArrayUtil.contains(vmQName, ourSwitchTypes))
		{
			return true;
		}

		if(DotNetTypes.System.Nullable$1.equals(vmQName))
		{
			int genericParametersCount = typeDeclaration.getGenericParametersCount();
			if(genericParametersCount > 0)
			{
				DotNetGenericParameter genericParameter = typeDeclaration.getGenericParameters()[0];

				DotNetGenericExtractor genericExtractor = typeResolveResult.getGenericExtractor();
				DotNetTypeRef extractedTypRef = genericExtractor.extract(genericParameter);
				if(extractedTypRef == null)
				{
					return false;
				}

				return isValidTypeRef(extractedTypRef);
			}
		}
	}

	return false;
}
 

@RequiredReadAction
@Nullable
@Override
public DotNetModifierList getModifierList()
{
	return null;
}
 

@Nonnull
@Override
@RequiredReadAction
public TextRange getTextRange()
{
	return myNode.getTextRange();
}
 

@Override
@RequiredReadAction
public PsiElement setName(@NonNls @Nonnull String s) throws IncorrectOperationException
{
	CSharpRefactoringUtil.replaceNameIdentifier(this, s);
	return this;
}
 

@RequiredReadAction
@Nullable
@Override
public PsiElement getNameIdentifier()
{
	return getReturnType();
}
 

@Nonnull
@Override
public PsiElementVisitor buildVisitor(@Nonnull final ProblemsHolder holder, boolean isOnTheFly)
{
	return new CSharpElementVisitor()
	{
		@Override
		@RequiredReadAction
		public void visitReferenceExpression(CSharpReferenceExpression expression)
		{
			PsiElement referenceElement = expression.getReferenceElement();
			if(referenceElement == null || expression.isSoft() || !CSharpDocUtil.isInsideDoc(expression))
			{
				return;
			}

			List<CompilerCheck.HighlightInfoFactory> factories = CC0001.checkReference(expression, Arrays.asList(referenceElement));
			if(factories.isEmpty())
			{
				return;
			}

			for(CompilerCheck.HighlightInfoFactory factory : factories)
			{
				HighlightInfo highlightInfo = factory.create(true);
				if(highlightInfo == null)
				{
					continue;
				}
				holder.registerProblem(expression, highlightInfo.getDescription());
			}
		}
	};
}
 

@RequiredReadAction
@Override
public boolean execute(@Nonnull PsiElement element, ResolveState state)
{
	if(!(element instanceof PsiNamedElement) || !ExecuteTargetUtil.isMyElement(this, element))
	{
		return true;
	}

	String name = ((PsiNamedElement) element).getName();
	if(name == null)
	{
		return true;
	}

	if(myCompletion)
	{
		return myCompletionProcessor.process(new CSharpResolveResult(element));
	}
	else
	{
		CSharpResolveSelector selector = state.get(CSharpResolveUtil.SELECTOR);
		if(!(selector instanceof CSharpNamedResolveSelector))
		{
			return true;
		}

		if(((CSharpNamedResolveSelector) selector).isNameEqual(name))
		{
			myCompletionProcessor.process(new CSharpResolveResult(element));
			return false;
		}
	}
	return true;
}
 

@Override
@RequiredReadAction
public boolean process(@Nonnull Project project, @Nonnull Editor editor, @Nonnull PsiFile psiFile)
{
	for(Fixer fixer : myFixers)
	{
		if(fixer.process(editor, psiFile))
		{
			return true;
		}
	}
	return false;
}
 

@Nullable
@RequiredReadAction
public static Pair<String, DotNetTypeDeclaration> resolveTypeElement(@Nonnull DotNetTypeRef typeRef)
{
	DotNetTypeResolveResult typeResolveResult = typeRef.resolve();

	PsiElement typeResolveResultElement = typeResolveResult.getElement();
	if(typeResolveResultElement instanceof DotNetTypeDeclaration)
	{
		return Pair.create(((DotNetTypeDeclaration) typeResolveResultElement).getVmQName(), (DotNetTypeDeclaration) typeResolveResultElement);
	}
	return null;
}
 

@RequiredReadAction
@Override
public void fillCompletionVariants(CompletionParameters parameters, CompletionResultSet result)
{
	CompletionResultSet resultSet = CSharpCompletionSorting.modifyResultSet(parameters, result);

	super.fillCompletionVariants(parameters, resultSet);

	CSharpNoVariantsDelegator.fillCompletionVariants(parameters, resultSet);
}
 

@RequiredReadAction
@Nonnull
@Override
protected DotNetTypeResolveResult resolveResult()
{
	return DotNetTypeResolveResult.EMPTY;
}
 

@RequiredReadAction
@Nonnull
@Override
public CSharpCallArgument[] getArguments()
{
	return findChildrenByClass(CSharpCallArgument.class);
}