public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
var symbolTable = ResolveUtil.GetSymbolTableByTypeElement(typeElement, SymbolTableMode.FULL, typeElement.Module);
symbolTable = symbolTable.Distinct().Filter(propertyFilter);
return(useReferenceName ? symbolTable.Filter(GetName(), exactNameFilter) : symbolTable);
}
public static bool IsForeachEnumeratorPatternMember(IDeclaredElement declaredElement)
{
var method = declaredElement as IMethod;
if (method != null)
{
// GetEnumerator
if (method.ShortName == "GetEnumerator" &&
method.Parameters.Count == 0 &&
!method.IsStatic &&
method.TypeParameters.Count == 0 &&
!method.IsExplicitImplementation &&
method.GetAccessRights() == AccessRights.PUBLIC)
{
return(true);
}
if (IsForeachMoveNextMethodCandidate(method))
{
ITypeElement containingType = method.GetContainingType();
if (containingType != null)
{
ISymbolTable symbolTable = ResolveUtil.GetSymbolTableByTypeElement(containingType, SymbolTableMode.FULL,
containingType.Module);
if (
symbolTable.GetSymbolInfos("Current").Any(
symbolInfo => IsForeachCurrentPropertyCandidate(symbolInfo.GetDeclaredElement() as IProperty)))
{
return(true);
}
}
}
}
var property = declaredElement as IProperty;
if (property != null)
{
if (IsForeachCurrentPropertyCandidate(property))
{
ITypeElement containingType = property.GetContainingType();
if (containingType != null)
{
ISymbolTable symbolTable = ResolveUtil.GetSymbolTableByTypeElement(containingType, SymbolTableMode.FULL,
containingType.Module);
if (
symbolTable.GetSymbolInfos("MoveNext").Any(
symbolInfo => IsForeachMoveNextMethodCandidate(symbolInfo.GetDeclaredElement() as IMethod)))
{
return(true);
}
}
}
}
return(false);
}
public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
var symbolTable = ResolveUtil.GetSymbolTableByTypeElement(_typeElement, SymbolTableMode.FULL, _typeElement.Module)
.Distinct(SymbolInfoComparer.Ordinal)
.Filter(IsDeclaredTypeMember);
return(useReferenceName
? symbolTable.Filter(x => x.ShortName == GetName())
: symbolTable);
}
public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
var symbolTable = ResolveUtil.GetSymbolTableByTypeElement(typeElement, SymbolTableMode.FULL, typeElement.Module);
// The NUnit code gets inheritors here, and adds all of those symbols, but I don't
// think that makes sense for xunit - the property needs to be a static property,
// so must be defined on this type or base types, which are already included
symbolTable = symbolTable.Distinct().Filter(propertyFilter);
return(useReferenceName ? symbolTable.Filter(GetName(), exactNameFilter) : symbolTable);
}
private ISymbolTable GetReferenceSymbolTable(ISolution solution, IPsiModule psiModule, AssetMethodData assetMethodData, string assetGuid)
{
var targetType = AssetUtils.GetTypeElementFromScriptAssetGuid(solution, assetGuid);
if (targetType == null)
{
return(EmptySymbolTable.INSTANCE);
}
var symbolTable = ResolveUtil.GetSymbolTableByTypeElement(targetType, SymbolTableMode.FULL, psiModule);
return(symbolTable.Filter(assetMethodData.MethodName, IsMethodFilter.INSTANCE, OverriddenFilter.INSTANCE, new ExactNameFilter(assetMethodData.MethodName),
new StaticFilter(new NonStaticAccessContext(null)), new EventHandlerSymbolFilter(assetMethodData.Mode, assetMethodData.Type, targetType.Module)));
}
public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
// Just resolve to the method. ReSharper will use GetSymbolFilters to filter
// candidates for errors
var symbolTable =
ResolveUtil.GetSymbolTableByTypeElement(myTargetType, SymbolTableMode.FULL, myTargetType.Module)
.Filter(myMethodFilter);
if (useReferenceName)
{
var name = GetName();
return(symbolTable.Filter(name, new ExactNameFilter(name)));
}
return(symbolTable);
}
public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
var assetGuid = GetScriptAssetGuid();
var targetType = UnityObjectPsiUtil.GetTypeElementFromScriptAssetGuid(myOwner.GetSolution(), assetGuid);
if (targetType == null)
{
return(EmptySymbolTable.INSTANCE);
}
var symbolTable = ResolveUtil.GetSymbolTableByTypeElement(targetType, SymbolTableMode.FULL, myOwner.GetPsiModule());
if (useReferenceName)
{
var name = GetName();
return(symbolTable.Filter(name, IsMethodFilter.INSTANCE, OverriddenFilter.INSTANCE, new ExactNameFilter(name),
new StaticFilter(new NonStaticAccessContext(myOwner)), new EventHandlerSymbolFilter(myMode, myType, targetType.Module)));
}
return(symbolTable);
}
public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
var assetGuid = GetScriptAssetGuid();
var targetType = UnityObjectPsiUtil.GetTypeElementFromScriptAssetGuid(myOwner.GetSolution(), assetGuid);
if (targetType == null)
{
return(EmptySymbolTable.INSTANCE);
}
var symbolTable =
ResolveUtil.GetSymbolTableByTypeElement(targetType, SymbolTableMode.FULL, myOwner.GetPsiModule());
if (useReferenceName)
{
var name = GetName();
return(symbolTable.Filter(name, new ExactNameFilter(name)));
}
return(symbolTable);
}
public override ISymbolTable GetReferenceSymbolTable(bool useReferenceName)
{
if (!myTargetType.IsValid())
{
return(EmptySymbolTable.INSTANCE);
}
// This symbol table is used for both resolve and completion. Return all possible candidates, and then
// filter appropriately for resolve (via GetSymbolFilters) and completion (via GetCompletionSymbolTable).
// Resolve will have stricter filtering - it's better for completion to show ALL methods and then show a
// resolve error for invalid signature than to confuse the user with missing methods in completion.
var symbolTable = ResolveUtil
.GetSymbolTableByTypeElement(myTargetType, SymbolTableMode.FULL, myTargetType.Module)
.Filter(myMethodFilter);
if (useReferenceName)
{
var name = GetName();
return(symbolTable.Filter(name, new ExactNameFilter(name)));
}
return(symbolTable);
}
private IEnumerable <ReplaceWithSimilarName> GetMostSimilarNamesBulbActions()
{
bool? isStaticReference;
ITypeElement typeElement = GetTypeElement(out isStaticReference);
var language = _expression.Language;
if (typeElement != null)
{
var symbolFilters = new List <ISymbolFilter>();
if (isStaticReference.HasValue)
{
symbolFilters.Add(new StaticOrInstanceFilter(isStaticReference.Value));
}
ConfigureFilters(symbolFilters);
var symbolTable = ResolveUtil.GetSymbolTableByTypeElement(typeElement, SymbolTableMode.FULL, _expression.GetPsiModule());
symbolTable = symbolTable.Filter(symbolFilters.ToArray());
IList <ReplaceWithSimilarName> result = new List <ReplaceWithSimilarName>();
HashSet <string> names = new HashSet <string>();
symbolTable.ForAllSymbolInfos(s =>
{
var symbolDeclaredElement = s.GetDeclaredElement();
if (!names.Contains(symbolDeclaredElement.ShortName))
{
names.Add(symbolDeclaredElement.ShortName);
if (CalculateLevenshteinDistance(_referenceName, symbolDeclaredElement.ShortName) <= _threshold)
{
result.Add(new ReplaceWithSimilarName(_expression, s.GetDeclaredElement(), language, CreateReplacementExpression));
}
}
});
return(result);
}
return(Enumerable.Empty <ReplaceWithSimilarName>());
}
private static void CheckForeachDeclaration(
[NotNull] IForeachStatement foreachStatement, [NotNull] IHighlightingConsumer consumer)
{
var collection = foreachStatement.Collection;
if (collection == null)
{
return;
}
var collectionType = collection.Type() as IDeclaredType;
if (collectionType == null || collectionType.IsUnknown)
{
return;
}
// no allocations because of compiler support (just like arrays)
if (collectionType.IsString())
{
return;
}
var typeElement = collectionType.GetTypeElement();
if (typeElement == null)
{
return;
}
// search for GetEnumerator() method
var symbolTable = ResolveUtil.GetSymbolTableByTypeElement(
typeElement, SymbolTableMode.FULL, typeElement.Module);
foreach (var symbolInfo in symbolTable.GetSymbolInfos("GetEnumerator"))
{
var method = symbolInfo.GetDeclaredElement() as IMethod;
if (method == null)
{
continue;
}
if (!CSharpDeclaredElementUtil.IsForeachEnumeratorPatternMember(method))
{
continue;
}
// with ref-return
if (method.ReturnType.Classify == TypeClassification.REFERENCE_TYPE)
{
DocumentRange range;
var inToken = collection.GetPreviousMeaningfulToken();
if (inToken != null && inToken.GetTokenType().IsKeyword)
{
range = inToken.GetDocumentRange();
}
else
{
range = collection.GetExpressionRange();
}
consumer.AddHighlighting(
new ObjectAllocationHighlighting(foreachStatement,
"possible enumerator allocation (except iterators or collection with cached enumerator)"),
range);
}
break;
}
}
