import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@Override
public void processElementsWithName(
		@NotNull String name, @NotNull Processor<NavigationItem> navigationItemProcessor, @NotNull FindSymbolParameters findSymbolParameters)
{
	Project project = findSymbolParameters.getProject();
	IdFilter idFilter = findSymbolParameters.getIdFilter();
	GlobalSearchScope searchScope = findSymbolParameters.getSearchScope();

	StubIndex.getInstance().processElements(CSharpIndexKeys.METHOD_INDEX, name, project, searchScope, idFilter,
			DotNetLikeMethodDeclaration.class, (Processor) navigationItemProcessor);
	StubIndex.getInstance().processElements(CSharpIndexKeys.EVENT_INDEX, name, project, searchScope, idFilter,
			DotNetEventDeclaration.class,  (Processor) navigationItemProcessor);
	StubIndex.getInstance().processElements(CSharpIndexKeys.PROPERTY_INDEX, name, project, searchScope, idFilter,
			DotNetPropertyDeclaration.class, (Processor) navigationItemProcessor);
	StubIndex.getInstance().processElements(CSharpIndexKeys.FIELD_INDEX, name, project, searchScope, idFilter,
			DotNetFieldDeclaration.class, (Processor) navigationItemProcessor);
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@RequiredReadAction
public static List<DotNetFieldDeclaration> getFields(CSharpTypeDeclaration typeDeclaration)
{
	List<DotNetFieldDeclaration> fieldDeclarations = new ArrayList<>(5);
	for(DotNetNamedElement dotNetNamedElement : typeDeclaration.getMembers())
	{
		if(dotNetNamedElement instanceof DotNetFieldDeclaration)
		{
			DotNetFieldDeclaration fieldDeclaration = (DotNetFieldDeclaration) dotNetNamedElement;
			if(CSharpPsiUtilImpl.isNullOrEmpty(fieldDeclaration))
			{
				continue;
			}
			fieldDeclarations.add(fieldDeclaration);
		}
	}
	return fieldDeclarations;
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@RequiredReadAction
@Override
public boolean isConstant()
{
	CSharpVariableDeclStub<DotNetFieldDeclaration> stub = getGreenStub();
	if(stub != null)
	{
		return stub.isConstant();
	}
	return CSharpStubVariableImplUtil.getConstantKeywordElement(this) != null;
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@Override
@RequiredReadAction
public void indexStub(@NotNull CSharpVariableDeclStub<DotNetFieldDeclaration> stub, @NotNull IndexSink indexSink)
{
	String name = getName(stub);
	if(!StringUtil.isEmpty(name))
	{
		indexSink.occurrence(CSharpIndexKeys.FIELD_INDEX, name);
	}
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@Nullable
@Override
@RequiredDispatchThread
public String getPresentableText()
{
	PsiNamedElement value = getValue();
	if(value instanceof DotNetLikeMethodDeclaration)
	{
		return CSharpElementPresentationUtil.formatMethod((DotNetLikeMethodDeclaration) value, CSharpElementPresentationUtil.METHOD_SCALA_LIKE_FULL);
	}
	else if(value instanceof DotNetTypeDeclaration)
	{
		return DotNetElementPresentationUtil.formatTypeWithGenericParameters((DotNetTypeDeclaration)value);
	}
	else if(value instanceof DotNetFieldDeclaration)
	{
		return CSharpElementPresentationUtil.formatField((DotNetFieldDeclaration) value);
	}
	else if(value instanceof DotNetPropertyDeclaration)
	{
		return CSharpElementPresentationUtil.formatProperty((DotNetPropertyDeclaration) value, CSharpElementPresentationUtil.PROPERTY_SCALA_LIKE_FULL);
	}
	else if(value instanceof DotNetNamespaceDeclaration)
	{
		return ((DotNetNamespaceDeclaration) value).getPresentableQName();
	}
	else
	{
		return value.getName();
	}
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@NotNull
@RequiredReadAction
public static String formatField(@NotNull DotNetFieldDeclaration fieldDeclaration, int flags)
{
	StringBuilder builder = new StringBuilder();
	builder.append(fieldDeclaration.getName());
	builder.append(":");
	CSharpTypeRefPresentationUtil.appendTypeRef(fieldDeclaration, builder, fieldDeclaration.toTypeRef(true), typeRefMask(flags));
	return builder.toString();
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@RequiredReadAction
private String generatePropertyTextFromField(String lineIndent, DotNetFieldDeclaration fieldDeclaration)
{
	StringBuilder builder = new StringBuilder();
	builder.append(lineIndent);
	CSharpAccessModifier accessModifier = CSharpAccessModifier.findModifier(fieldDeclaration);
	if(accessModifier != CSharpAccessModifier.NONE)
	{
		builder.append(accessModifier.getPresentableText()).append(" ");
	}

	if(fieldDeclaration.hasModifier(DotNetModifier.STATIC))
	{
		builder.append("static ");
	}

	builder.append(fieldDeclaration.getType().getText()).append(" ");
	String fieldName = fieldDeclaration.getName();
	builder.append(getPropertyName(fieldDeclaration.getProject(), fieldDeclaration.hasModifier(DotNetModifier.STATIC), fieldName));
	builder.append("{get { return ").append(fieldName).append("; }");
	if(!myReadonly)
	{
		builder.append("set { ").append(fieldName).append(" = value; }");
	}
	builder.append("}");
	return builder.toString();
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@RequiredReadAction
@NotNull
@Override
public String getPresentationText()
{
	if(myDeclaration instanceof CSharpFieldDeclaration)
	{
		return CSharpElementPresentationUtil.formatField((DotNetFieldDeclaration) myDeclaration);
	}
	else if(myDeclaration instanceof CSharpPropertyDeclaration)
	{
		return CSharpElementPresentationUtil.formatProperty((CSharpPropertyDeclaration) myDeclaration, CSharpElementPresentationUtil.SCALA_FORMAT);
	}
	throw new IllegalArgumentException(myDeclaration.getClass().getName());
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@NotNull
@Deprecated
public static String formatField(@NotNull DotNetFieldDeclaration fieldDeclaration)
{
	StringBuilder builder = new StringBuilder();
	builder.append(fieldDeclaration.getName());
	builder.append(":");
	builder.append(fieldDeclaration.toTypeRef(true).getPresentableText());
	return builder.toString();
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@NotNull
@Override
@RequiredReadAction
public DotNetTypeRef fun(MsilClassEntryImpl msilClassEntry)
{
	DotNetFieldDeclaration value = findFieldByName(msilClassEntry, "__value");
	return value != null ? value.toTypeRef(false) : new MsilNativeTypeRefImpl(msilClassEntry, DotNetTypes.System.Int32);
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@Nullable
private static DotNetFieldDeclaration findFieldByName(@NotNull DotNetTypeDeclaration tp, @NotNull String name)
{
	for(DotNetNamedElement element : tp.getMembers())
	{
		if(element instanceof DotNetFieldDeclaration && Comparing.equal(element.getName(), name))
		{
			return (DotNetFieldDeclaration) element;
		}
	}
	return null;
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
public CSharpLightFieldDeclaration(DotNetFieldDeclaration original, DotNetTypeRef typeRef)
{
	super(original);
	myTypeRef = typeRef;
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
public CSharpFieldDeclarationImpl(@NotNull CSharpVariableDeclStub<DotNetFieldDeclaration> stub)
{
	super(stub, CSharpStubElements.FIELD_DECLARATION);
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@NotNull
@Override
public DotNetFieldDeclaration createElement(@NotNull ASTNode astNode)
{
	return new CSharpFieldDeclarationImpl(astNode);
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@Override
public DotNetFieldDeclaration createPsi(@NotNull CSharpVariableDeclStub<DotNetFieldDeclaration> fieldStub)
{
	return new CSharpFieldDeclarationImpl(fieldStub);
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@NotNull
@Override
public StubIndexKey<String, DotNetFieldDeclaration> getKey()
{
	return CSharpIndexKeys.FIELD_INDEX;
}
 

import consulo.dotnet.psi.DotNetFieldDeclaration; //导入依赖的package包/类
@RequiredReadAction
@Nullable
@Override
public HighlightInfoFactory checkImpl(@NotNull CSharpLanguageVersion languageVersion, @NotNull CSharpHighlightContext highlightContext, @NotNull CSharpNativeType element)
{
	if(highlightContext.getFile().getUserData(ourReturnTypeFlag) == Boolean.TRUE)
	{
		return null;
	}

	IElementType typeElementType = element.getTypeElementType();
	if(typeElementType == CSharpTokens.VOID_KEYWORD)
	{
		PsiElement parent = element.getParent();
		if(parent instanceof CSharpTypeOfExpressionImpl)
		{
			return null;
		}
		if(!(parent instanceof DotNetLikeMethodDeclaration))
		{
			if(parent instanceof DotNetFieldDeclaration)
			{
				if(((DotNetFieldDeclaration) parent).isConstant() || ((DotNetFieldDeclaration) parent).getInitializer() != null)
				{
					return newBuilder(element, VOID);
				}

				PsiElement lastChild = parent.getLastChild();
				// dont show error while typing
				if(lastChild instanceof PsiErrorElement)
				{
					return null;
				}
			}
			return newBuilder(element, VOID);
		}

		DotNetType returnType = ((DotNetLikeMethodDeclaration) parent).getReturnType();
		if(returnType != element)
		{
			return newBuilder(element, VOID);
		}
	}
	return null;
}