public static List <SymbolDeclaration> FindDeclarations(SymbolDefinition symbol)
{
var candidates = FindDefinitionCandidates(symbol);
foreach (var c in candidates)
{
var asset = AssetDatabase.LoadAssetAtPath(c, typeof(TextAsset)) as TextAsset;
if (!asset)
{
continue;
}
var buffer = FGTextBufferManager.GetBuffer(asset);
buffer.LoadImmediately();
}
var newSymbol = FindNewSymbol(symbol);
return(newSymbol == null ? null : newSymbol.declarations);
}
static FindResultsWindow.ResultType ValidateResultAsReference(string assetGuid, TextPosition location, int length, ref SymbolDefinition referencedSymbol)
{
var assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
if (string.IsNullOrEmpty(assetPath))
{
return(FindResultsWindow.ResultType.RemoveResult);
}
var isCsScript = assetPath.EndsWith(".cs", System.StringComparison.OrdinalIgnoreCase);
var buffer = FGTextBufferManager.GetBuffer(assetGuid);
if (buffer == null)
{
return(FindResultsWindow.ResultType.RemoveResult);
}
if (buffer.Parser == null)
{
buffer.LoadImmediately();
referencedSymbol = referencedSymbol.Rebind();
}
var formatedLine = buffer.formatedLines[location.line];
var textLine = buffer.lines[location.line];
var isVarResult = length == 3 && (referencedSymbol is TypeDefinitionBase) && textLine.Substring(location.index, length) == "var";
if (isCsScript)
{
if (formatedLine.regionTree.kind > FGTextBuffer.RegionTree.Kind.LastActive)
{
if (isVarResult)
{
return(FindResultsWindow.ResultType.RemoveResult);
}
return(FindResultsWindow.ResultType.InactiveCode);
}
}
else if (isVarResult)
{
return(FindResultsWindow.ResultType.RemoveResult);
}
int tokenIndex;
bool atTokenEnd;
var token = buffer.GetTokenAt(new TextPosition(location.line, location.index + 1), out location.line, out tokenIndex, out atTokenEnd);
switch (token.tokenKind)
{
case SyntaxToken.Kind.Preprocessor:
return(FindResultsWindow.ResultType.RemoveResult);
case SyntaxToken.Kind.Comment:
case SyntaxToken.Kind.PreprocessorArguments:
case SyntaxToken.Kind.PreprocessorSymbol:
if (isVarResult)
{
return(FindResultsWindow.ResultType.RemoveResult);
}
return(FindResultsWindow.ResultType.Comment);
case SyntaxToken.Kind.StringLiteral:
case SyntaxToken.Kind.VerbatimStringLiteral:
if (isVarResult)
{
return(FindResultsWindow.ResultType.RemoveResult);
}
return(FindResultsWindow.ResultType.String);
}
if (!isCsScript || token.parent == null)
{
return(FindResultsWindow.ResultType.UnresolvedSymbol);
}
var resolvedSymbol = token.parent.resolvedSymbol;
if (resolvedSymbol == null || resolvedSymbol.kind == SymbolKind.Error)
{
FGResolver.ResolveNode(token.parent.parent);
}
if (resolvedSymbol != null && resolvedSymbol.kind == SymbolKind.MethodGroup && token.parent.parent != null)
{
var nextLeaf = token.parent.parent.FindNextLeaf();
if (nextLeaf != null && nextLeaf.IsLit("("))
{
var nextNode = nextLeaf.parent;
if (nextNode.RuleName == "arguments")
{
FGResolver.ResolveNode(nextNode);
if (token.parent != null)
{
if (token.parent.resolvedSymbol == null || token.parent.resolvedSymbol.kind == SymbolKind.Error)
{
token.parent.resolvedSymbol = resolvedSymbol;
}
}
}
}
}
resolvedSymbol = token.parent != null ? token.parent.resolvedSymbol : null;
if (resolvedSymbol == null || resolvedSymbol.kind == SymbolKind.Error)
{
return(FindResultsWindow.ResultType.UnresolvedSymbol);
}
if (resolvedSymbol.kind == SymbolKind.Constructor || resolvedSymbol.kind == SymbolKind.Destructor)
{
resolvedSymbol = resolvedSymbol.parentSymbol;
}
if (resolvedSymbol == null || resolvedSymbol.kind == SymbolKind.Error)
{
return(FindResultsWindow.ResultType.UnresolvedSymbol);
}
var constructedSymbol = resolvedSymbol;
resolvedSymbol = resolvedSymbol.GetGenericSymbol();
if (referencedSymbol.kind == SymbolKind.MethodGroup && resolvedSymbol.kind == SymbolKind.Method)
{
resolvedSymbol = resolvedSymbol.parentSymbol;
}
if (resolvedSymbol != referencedSymbol)
{
var typeArgument = referencedSymbol as TypeDefinitionBase;
var constructedType = constructedSymbol as ConstructedTypeDefinition;
if (isVarResult && typeArgument != null && constructedType != null)
{
if (IsUsedAsTypeArgument(typeArgument.GetGenericSymbol() as TypeDefinitionBase, constructedType))
{
return(FindResultsWindow.ResultType.VarTemplateReference);
}
}
if (resolvedSymbol.kind == SymbolKind.Method && referencedSymbol.kind == SymbolKind.Method)
{
if (resolvedSymbol.parentSymbol == referencedSymbol.parentSymbol)
{
return(FindResultsWindow.ResultType.MethodOverload);
}
var resolvedMethod = resolvedSymbol as MethodDefinition;
var referencedMethod = referencedSymbol as MethodDefinition;
if (resolvedMethod != null && referencedMethod != null)
{
var resolvedType = resolvedMethod.parentSymbol as TypeDefinitionBase
?? resolvedMethod.parentSymbol.parentSymbol as TypeDefinitionBase;
var referencedType = referencedMethod.parentSymbol as TypeDefinitionBase
?? referencedMethod.parentSymbol.parentSymbol as TypeDefinitionBase;
var isInterface = resolvedType.kind == SymbolKind.Interface || referencedType.kind == SymbolKind.Interface;
var resolvedIsVirtual = isInterface || resolvedMethod.IsOverride || resolvedMethod.IsVirtual || resolvedMethod.IsAbstract;
var referencedIsVirtual = isInterface || referencedMethod.IsOverride || referencedMethod.IsVirtual || referencedMethod.IsAbstract;
if (resolvedIsVirtual && referencedIsVirtual)
{
if (System.Linq.Enumerable.SequenceEqual(
System.Linq.Enumerable.Select(resolvedMethod.GetParameters(), x => x.TypeOf()),
System.Linq.Enumerable.Select(referencedMethod.GetParameters(), x => x.TypeOf())))
{
if (resolvedType.DerivesFrom(referencedType))
{
return(FindResultsWindow.ResultType.OverridingMethod);
}
if (referencedType.DerivesFrom(resolvedType))
{
return(FindResultsWindow.ResultType.OverriddenMethod);
}
}
}
}
}
if (resolvedSymbol.kind != SymbolKind.MethodGroup || referencedSymbol.parentSymbol != resolvedSymbol)
{
return(FindResultsWindow.ResultType.RemoveResult);
}
}
if (isVarResult)
{
return(FindResultsWindow.ResultType.VarReference);
}
if (FGResolver.IsWriteReference(token))
{
return(FindResultsWindow.ResultType.WriteReference);
}
return(FindResultsWindow.ResultType.ReadReference);
}
private void ReplaceAll()
{
Unsubscribe();
FGTextBuffer buffer = null;
string guid = null;
bool canEditAll = true;
var canEditBuffers = new HashSet <FGTextBuffer>();
for (var i = flatResults.Count; i-- > 0;)
{
var result = flatResults[i];
if (!result.selected)
{
continue;
}
if (result.assetGuid != guid)
{
guid = result.assetGuid;
buffer = FGTextBufferManager.GetBuffer(guid);
if (buffer.IsLoading)
{
buffer.LoadImmediately();
}
if (FGCodeWindow.CodeWindows.All(x => x.TargetAssetGuid != guid))
{
var wnd = FGCodeWindow.OpenAssetInTab(guid);
if (wnd)
{
wnd.OnFirstUpdate();
}
}
if (!buffer.TryEdit())
{
canEditAll = false;
}
else
{
canEditBuffers.Add(buffer);
}
}
}
if (!canEditAll)
{
if (!EditorUtility.DisplayDialog("Replace", "Some assets are locked and cannot be edited!", "Continue Anyway", "Cancel"))
{
Close();
}
}
buffer = null;
guid = null;
var updatedLines = new HashSet <int>();
for (var i = flatResults.Count; i-- > 0;)
{
var result = flatResults[i];
if (!result.selected)
{
continue;
}
if (result.assetGuid != guid)
{
if (buffer != null)
{
foreach (var line in updatedLines)
{
buffer.UpdateHighlighting(line, line);
}
buffer.EndEdit();
FGTextBufferManager.AddBufferToGlobalUndo(buffer);
updatedLines.Clear();
}
guid = result.assetGuid;
buffer = FGTextBufferManager.GetBuffer(guid);
if (buffer != null)
{
if (canEditBuffers.Contains(buffer))
{
buffer.BeginEdit("*Replace All");
}
else
{
buffer = null;
}
}
}
if (buffer != null)
{
var from = new FGTextBuffer.CaretPos {
line = result.line, characterIndex = result.characterIndex
};
var to = new FGTextBuffer.CaretPos {
line = result.line, characterIndex = result.characterIndex + result.length
};
var insertAt = buffer.DeleteText(from, to);
if (replaceText != "")
{
buffer.InsertText(insertAt, replaceText);
}
updatedLines.Add(result.line);
}
}
if (buffer != null)
{
foreach (var line in updatedLines)
{
buffer.UpdateHighlighting(line, line);
}
buffer.EndEdit();
FGTextBufferManager.AddBufferToGlobalUndo(buffer);
}
FGTextBufferManager.RecordGlobalUndo();
Close();
}
