private ResolvedSymbols GetResolvedSymbols()
{
lock (myLock)
{
if (mySymbols != null)
{
return(mySymbols);
}
mySymbols = CreateFileResolvedSymbols();
return(mySymbols);
}
}
public void Load(string fn)
{
using (var stream = File.Open(fn, FileMode.Open, FileAccess.Read, FileShare.Read))
{
FileSize = stream.Length;
// Figure out what the footer looks like
using (var br = new BinaryReader(stream, Encoding.UTF8, /*leaveOpen:*/ true))
{
// Seek to last 8 bytes.
stream.Position = stream.Length - 8;
// Read position of footer.
long footer_pos = br.ReadInt64();
// Stash length of compressed data preceding the footer.
FooterPosition = footer_pos;
stream.Position = footer_pos;
// Slurp in the serialized footer.
uint magic = br.ReadUInt32();
Version = Array.IndexOf(AllMagics, magic);
if (Version == -1)
{
throw new IOException(String.Format("Expected decorated stream magic {0:x8}, got {1:x8}. Old file?", V2Magic, magic));
}
PlatformName = br.ReadString();
PointerSizeBytes = br.ReadInt32();
EventCount = br.ReadInt64();
WireSizeBytes = br.ReadInt64();
SourceMachine = br.ReadString();
MaxTimeStamp = br.ReadUInt64();
TimerFrequency = br.ReadUInt64();
EncodedDataSizeBytes = br.ReadInt64();
{
int modcount = br.ReadInt32();
Modules = new List <ModuleInfo>(modcount);
for (int i = 0; i < modcount; ++i)
{
var name = br.ReadString();
var baseaddr = br.ReadUInt64();
var size = br.ReadUInt64();
Modules.Add(new ModuleInfo {
Name = name, BaseAddress = baseaddr, SizeBytes = size
});
}
}
{
int markcount = br.ReadInt32();
m_Marks.Clear();
for (int i = 0; i < markcount; ++i)
{
var name = br.ReadString();
var time = br.ReadUInt64();
AddMark(new TraceMark {
Name = name, TimeStamp = time
});
}
}
{
int symcount = br.ReadInt32();
Symbols = new List <ulong>(symcount);
for (int i = 0; i < symcount; ++i)
{
var addr = br.ReadUInt64();
Symbols.Add(addr);
}
}
{
ResolvedSymbols.Clear();
int rsymcount = br.ReadInt32();
for (int i = 0; i < rsymcount; ++i)
{
var sym = new SymbolInfo();
ulong addr = br.ReadUInt64();
sym.FileName = br.ReadString();
sym.LineNumber = br.ReadInt32();
sym.Symbol = br.ReadString();
ResolvedSymbols[addr] = sym;
}
}
if (Version > 0)
{
MemTraceInitCommonAddress = br.ReadUInt64();
}
if (Version > 1)
{
ExecutableName = br.ReadString();
WarningCount = br.ReadInt32();
}
if (Version > 3)
{
int warnTextCount = br.ReadInt32();
for (int i = 0; i < warnTextCount; ++i)
{
Warnings.Add(br.ReadString());
}
}
}
}
}
bool Execute(DirectoryAssemblyResolver resolver)
{
LogDebugMessage("ResolveAssemblies Task");
LogDebugMessage(" ReferenceAssembliesDirectory: {0}", ReferenceAssembliesDirectory);
LogDebugMessage(" I18nAssemblies: {0}", I18nAssemblies);
LogDebugMessage(" LinkMode: {0}", LinkMode);
LogDebugTaskItems(" Assemblies:", Assemblies);
LogDebugMessage(" ProjectAssetFile: {0}", ProjectAssetFile);
LogDebugMessage(" NuGetPackageRoot: {0}", NuGetPackageRoot);
LogDebugMessage(" TargetMoniker: {0}", TargetMoniker);
foreach (var dir in ReferenceAssembliesDirectory.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
resolver.SearchDirectories.Add(dir);
}
var assemblies = new HashSet <string> ();
var topAssemblyReferences = new List <AssemblyDefinition> ();
var logger = new NuGetLogger((s) => {
LogDebugMessage("{0}", s);
});
LockFile lockFile = null;
if (!string.IsNullOrEmpty(ProjectAssetFile) && File.Exists(ProjectAssetFile))
{
lockFile = LockFileUtilities.GetLockFile(ProjectAssetFile, logger);
}
try {
foreach (var assembly in Assemblies)
{
var assembly_path = Path.GetDirectoryName(assembly.ItemSpec);
if (!resolver.SearchDirectories.Contains(assembly_path))
{
resolver.SearchDirectories.Add(assembly_path);
}
// Add each user assembly and all referenced assemblies (recursive)
var assemblyDef = resolver.Load(assembly.ItemSpec);
if (assemblyDef == null)
{
throw new InvalidOperationException("Failed to load assembly " + assembly.ItemSpec);
}
if (MonoAndroidHelper.IsReferenceAssembly(assemblyDef))
{
// Resolve "runtime" library
if (lockFile != null)
{
assemblyDef = ResolveRuntimeAssemblyForReferenceAssembly(lockFile, resolver, assemblyDef.Name);
}
if (lockFile == null || assemblyDef == null)
{
LogWarning($"Ignoring {assembly_path} as it is a Reference Assembly");
continue;
}
}
topAssemblyReferences.Add(assemblyDef);
assemblies.Add(Path.GetFullPath(assemblyDef.MainModule.FullyQualifiedName));
}
} catch (Exception ex) {
LogError("Exception while loading assemblies: {0}", ex);
return(false);
}
try {
foreach (var assembly in topAssemblyReferences)
{
AddAssemblyReferences(resolver, assemblies, assembly, true);
}
} catch (Exception ex) {
LogError("Exception while loading assemblies: {0}", ex);
return(false);
}
// Add I18N assemblies if needed
AddI18nAssemblies(resolver, assemblies);
ResolvedAssemblies = assemblies.Select(a => new TaskItem(a)).ToArray();
ResolvedSymbols = assemblies.Select(a => a + ".mdb").Where(a => File.Exists(a)).Select(a => new TaskItem(a)).ToArray();
ResolvedSymbols = ResolvedSymbols.Concat(
assemblies.Select(a => Path.ChangeExtension(a, "pdb"))
.Where(a => File.Exists(a) && Files.IsPortablePdb(a))
.Select(a => new TaskItem(a)))
.ToArray();
ResolvedFrameworkAssemblies = ResolvedAssemblies.Where(p => MonoAndroidHelper.IsFrameworkAssembly(p.ItemSpec, true)).ToArray();
ResolvedUserAssemblies = ResolvedAssemblies.Where(p => !MonoAndroidHelper.IsFrameworkAssembly(p.ItemSpec, true)).ToArray();
ResolvedDoNotPackageAttributes = do_not_package_atts.ToArray();
LogDebugTaskItems(" [Output] ResolvedAssemblies:", ResolvedAssemblies);
LogDebugTaskItems(" [Output] ResolvedUserAssemblies:", ResolvedUserAssemblies);
LogDebugTaskItems(" [Output] ResolvedFrameworkAssemblies:", ResolvedFrameworkAssemblies);
LogDebugTaskItems(" [Output] ResolvedDoNotPackageAttributes:", ResolvedDoNotPackageAttributes);
return(!Log.HasLoggedErrors);
}
private ResolvedSymbols CreateFileResolvedSymbols()
{
var interruptChecker = new SeldomInterruptCheckerWithCheckTime(100);
// todo: cancellation
if (!(SourceFile.GetPrimaryPsiFile() is IFSharpFile fsFile))
{
return(ResolvedSymbols.Empty);
}
var checkResults = CheckerService.ParseAndCheckFile(SourceFile, OpName)?.Value.CheckResults;
var symbolUses = checkResults?.GetAllUsesOfAllSymbolsInFile().RunAsTask();
if (symbolUses == null)
{
return(ResolvedSymbols.Empty);
}
var document = SourceFile.Document;
var lexer = fsFile.CachingLexer;
var buffer = document.Buffer;
var resolvedSymbols = new ResolvedSymbols(symbolUses.Length);
foreach (var symbolUse in symbolUses)
{
var symbol = symbolUse.Symbol;
var range = symbolUse.RangeAlternate;
var startOffset = document.GetOffset(range.Start);
var endOffset = document.GetOffset(range.End);
var mfv = symbol as FSharpMemberOrFunctionOrValue;
var activePatternCase = symbol as FSharpActivePatternCase;
if (symbolUse.IsFromDefinition)
{
if (mfv != null)
{
// workaround for auto-properties, see visualfsharp#3939
var mfvLogicalName = mfv.LogicalName;
if (mfvLogicalName.EndsWith("@", StringComparison.Ordinal))
{
continue;
}
// visualfsharp#3939
if (mfvLogicalName == "v" &&
resolvedSymbols.Declarations.ContainsKey(startOffset))
{
continue;
}
if (mfvLogicalName == StandardMemberNames.ClassConstructor)
{
continue;
}
// visualfsharp#3943, visualfsharp#3933
if (mfvLogicalName != StandardMemberNames.Constructor &&
!(lexer.FindTokenAt(endOffset - 1) && (lexer.TokenType?.IsIdentifier ?? false) || mfv.IsActivePattern))
{
continue;
}
if (mfvLogicalName == "Invoke" && (mfv.DeclaringEntity?.Value?.IsDelegate ?? false))
{
continue;
}
var len = endOffset - startOffset;
if (mfvLogicalName == "op_Multiply" && len == 3)
{
// The `*` pattern includes parens and is parsed as special token
// let (*) (_, _) = ()
startOffset++;
endOffset--;
}
}
else if (activePatternCase != null)
{
// Skip active pattern cases bindings as these have incorrect ranges.
// Active pattern cases uses inside bindings are currently marked as bindings so check the range.
// https://github.com/Microsoft/visualfsharp/issues/4423
if (Range.equals(activePatternCase.DeclarationLocation, range))
{
var activePatternId = fsFile.GetContainingNodeAt <ActivePatternId>(new TreeOffset(endOffset - 1));
if (activePatternId == null)
{
continue;
}
var cases = activePatternId.Cases;
var caseIndex = activePatternCase.Index;
if (caseIndex < 0 || caseIndex >= cases.Count)
{
continue;
}
if (!(cases[caseIndex] is IActivePatternNamedCaseDeclaration caseDeclaration))
{
continue;
}
var(caseStart, caseEnd) = caseDeclaration.GetTreeTextRange();
var caseStartOffset = caseStart.Offset;
var caseTextRange = new TextRange(caseStartOffset, caseEnd.Offset);
resolvedSymbols.Declarations[caseStartOffset] = new FSharpResolvedSymbolUse(symbolUse, caseTextRange);
continue;
}
var caseUseInBindingRange = new TextRange(startOffset, endOffset);
resolvedSymbols.Uses[startOffset] = new FSharpResolvedSymbolUse(symbolUse, caseUseInBindingRange);
continue;
}
else
{
// workaround for compiler generated symbols (e.g. fields auto-properties)
if (!(lexer.FindTokenAt(endOffset - 1) && (lexer.TokenType?.IsIdentifier ?? false)))
{
continue;
}
}
var textRange = mfv != null
? new TextRange(startOffset, endOffset)
: FixRange(startOffset, endOffset, null, buffer, lexer);
startOffset = textRange.StartOffset;
resolvedSymbols.Declarations[startOffset] = new FSharpResolvedSymbolUse(symbolUse, textRange);
resolvedSymbols.Uses.Remove(startOffset);
}
else
{
// workaround for indexer properties, visualfsharp#3933
if (startOffset == endOffset ||
mfv != null && mfv.IsProperty && buffer[endOffset - 1] == ']')
{
continue;
}
var entity =
symbol as FSharpEntity ??
(mfv != null && mfv.IsConstructor ? mfv.DeclaringEntity?.Value : null);
// we need `foo` in
// inherit mod.foo<bar.baz>()
if (entity != null && !entity.GenericParameters.IsEmpty())
{
if (lexer.FindTokenAt(endOffset - 1) && lexer.TokenType == FSharpTokenType.GREATER)
{
if (new ParenMatcher().FindMatchingBracket(lexer) && lexer.TokenStart >= startOffset)
{
lexer.Advance(-1);
if (lexer.TokenType != null)
{
startOffset = lexer.TokenStart;
endOffset = lexer.TokenEnd;
}
}
}
}
var nameRange = FixRange(startOffset, endOffset, mfv?.LogicalName, buffer, lexer);
startOffset = nameRange.StartOffset;
// workaround for implicit type usages (e.g. in members with optional params), visualfsharp#3933
if (CanIgnoreSymbol(symbol) &&
!(lexer.FindTokenAt(nameRange.EndOffset - 1) && (lexer.TokenType?.IsIdentifier ?? false)))
{
continue;
}
if (!resolvedSymbols.Declarations.ContainsKey(startOffset))
{
resolvedSymbols.Uses[startOffset] = new FSharpResolvedSymbolUse(symbolUse, nameRange);
}
}
interruptChecker.CheckForInterrupt();
}
return(resolvedSymbols);
}
bool Execute(DirectoryAssemblyResolver resolver)
{
Log.LogDebugMessage("ResolveAssemblies Task");
Log.LogDebugMessage(" ReferenceAssembliesDirectory: {0}", ReferenceAssembliesDirectory);
Log.LogDebugMessage(" I18nAssemblies: {0}", I18nAssemblies);
Log.LogDebugMessage(" LinkMode: {0}", LinkMode);
Log.LogDebugTaskItems(" Assemblies:", Assemblies);
foreach (var dir in ReferenceAssembliesDirectory.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
resolver.SearchDirectories.Add(dir);
}
var assemblies = new HashSet <string> ();
var topAssemblyReferences = new List <AssemblyDefinition> ();
try {
foreach (var assembly in Assemblies)
{
var assembly_path = Path.GetDirectoryName(assembly.ItemSpec);
if (!resolver.SearchDirectories.Contains(assembly_path))
{
resolver.SearchDirectories.Add(assembly_path);
}
// Add each user assembly and all referenced assemblies (recursive)
var assemblyDef = resolver.Load(assembly.ItemSpec);
if (assemblyDef == null)
{
throw new InvalidOperationException("Failed to load assembly " + assembly.ItemSpec);
}
topAssemblyReferences.Add(assemblyDef);
assemblies.Add(Path.GetFullPath(assemblyDef.MainModule.FullyQualifiedName));
}
} catch (Exception ex) {
Log.LogError("Exception while loading assemblies: {0}", ex);
return(false);
}
try {
foreach (var assembly in topAssemblyReferences)
{
AddAssemblyReferences(resolver, assemblies, assembly, true);
}
} catch (Exception ex) {
Log.LogError("Exception while loading assemblies: {0}", ex);
return(false);
}
// Add I18N assemblies if needed
AddI18nAssemblies(resolver, assemblies);
ResolvedAssemblies = assemblies.Select(a => new TaskItem(a)).ToArray();
ResolvedSymbols = assemblies.Select(a => a + ".mdb").Where(a => File.Exists(a)).Select(a => new TaskItem(a)).ToArray();
ResolvedSymbols = ResolvedSymbols.Concat(
assemblies.Select(a => Path.ChangeExtension(a, "pdb"))
.Where(a => File.Exists(a) && Files.IsPortablePdb(a))
.Select(a => new TaskItem(a)))
.ToArray();
ResolvedFrameworkAssemblies = ResolvedAssemblies.Where(p => MonoAndroidHelper.IsFrameworkAssembly(p.ItemSpec, true)).ToArray();
ResolvedUserAssemblies = ResolvedAssemblies.Where(p => !MonoAndroidHelper.IsFrameworkAssembly(p.ItemSpec, true)).ToArray();
ResolvedDoNotPackageAttributes = do_not_package_atts.ToArray();
Log.LogDebugTaskItems(" [Output] ResolvedAssemblies:", ResolvedAssemblies);
Log.LogDebugTaskItems(" [Output] ResolvedUserAssemblies:", ResolvedUserAssemblies);
Log.LogDebugTaskItems(" [Output] ResolvedFrameworkAssemblies:", ResolvedFrameworkAssemblies);
Log.LogDebugTaskItems(" [Output] ResolvedDoNotPackageAttributes:", ResolvedDoNotPackageAttributes);
return(!Log.HasLoggedErrors);
}
