public static string GetAssemblyInfo(IAssemblySymbol assemblySymbol)
{
return string.Format(
"{0} {1}",
FeaturesResources.Assembly,
assemblySymbol.Identity.GetDisplayName());
}
private static bool ShouldCreateFromScratch(
Solution solution,
IAssemblySymbol assembly,
string filePath,
out string prefix,
out VersionStamp version,
CancellationToken cancellationToken)
{
prefix = null;
version = default(VersionStamp);
var service = solution.Workspace.Services.GetService<IAssemblySerializationInfoService>();
if (service == null)
{
return true;
}
// check whether the assembly that belong to a solution is something we can serialize
if (!service.Serializable(solution, filePath))
{
return true;
}
if (!service.TryGetSerializationPrefixAndVersion(solution, filePath, out prefix, out version))
{
return true;
}
return false;
}
protected void AddAssemblyLink(IAssemblySymbol assemblySymbol)
{
var name = assemblySymbol.Identity.Name;
var navInfo = _libraryManager.LibraryService.NavInfoFactory.CreateForAssembly(assemblySymbol);
_description.AddDescriptionText3(name, VSOBDESCRIPTIONSECTION.OBDS_TYPE, navInfo);
}
/// <summary>
/// Checks if 'symbol' is accessible from within assembly 'within'.
/// </summary>
public static bool IsAccessibleWithin(
this ISymbol symbol,
IAssemblySymbol within,
ITypeSymbol throughTypeOpt = null)
{
return IsSymbolAccessibleCore(symbol, within, throughTypeOpt, out var failedThroughTypeCheck);
}
protected void AddAssemblyLink(IAssemblySymbol assemblySymbol)
{
var name = assemblySymbol.Identity.Name;
var navInfo = _libraryManager.GetAssemblyNavInfo(assemblySymbol);
_description.AddDescriptionText3(name, VSOBDESCRIPTIONSECTION.OBDS_TYPE, navInfo);
}
public static IEnumerable<TypeDiff> CompareTo(this IAssemblySymbol assembly, IAssemblySymbol comparedTo)
{
var types = assembly.GlobalNamespace.GetTypes();
var comparedToTypes = comparedTo.GlobalNamespace.GetTypes();
var result = types.FullOuterJoin(comparedToTypes, NamespaceOrTypeSymbolComparer.Instance, (a, b) => a.CompareTo(b));
return result;
}
public static bool IsSameAssemblyOrHasFriendAccessTo(this IAssemblySymbol assembly, IAssemblySymbol toAssembly)
{
return
Equals(assembly, toAssembly) ||
(assembly.IsInteractive && toAssembly.IsInteractive) ||
toAssembly.GivesAccessTo(assembly);
}
/// <summary>
/// this is for a metadata reference in a solution
/// </summary>
private static async Task<SymbolTreeInfo> LoadOrCreateAsync(Solution solution, IAssemblySymbol assembly, string filePath, CancellationToken cancellationToken)
{
// if assembly is not from a file, just create one on the fly
if (filePath == null || !File.Exists(filePath) || !FilePathUtilities.PartOfFrameworkOrReferencePaths(filePath))
{
return Create(VersionStamp.Default, assembly, cancellationToken);
}
// if solution is not from a disk, just create one.
if (solution.FilePath == null || !File.Exists(solution.FilePath))
{
return Create(VersionStamp.Default, assembly, cancellationToken);
}
// okay, see whether we can get one from persistence service.
var relativePath = FilePathUtilities.GetRelativePath(solution.FilePath, filePath);
var version = VersionStamp.Create(File.GetLastWriteTimeUtc(filePath));
var persistentStorageService = solution.Workspace.Services.GetService<IPersistentStorageService>();
// attempt to load from persisted state. metadata reference is solution wise information
SymbolTreeInfo info;
using (var storage = persistentStorageService.GetStorage(solution))
{
var key = PrefixMetadataSymbolTreeInfo + relativePath;
using (var stream = await storage.ReadStreamAsync(key, cancellationToken).ConfigureAwait(false))
{
if (stream != null)
{
using (var reader = new ObjectReader(stream))
{
info = ReadFrom(reader);
if (info != null && VersionStamp.CanReusePersistedVersion(version, info.version))
{
return info;
}
}
}
}
cancellationToken.ThrowIfCancellationRequested();
// compute it if we couldn't load it from cache
info = Create(version, assembly, cancellationToken);
if (info != null)
{
using (var stream = SerializableBytes.CreateWritableStream())
using (var writer = new ObjectWriter(stream, cancellationToken: cancellationToken))
{
info.WriteTo(writer);
stream.Position = 0;
await storage.WriteStreamAsync(key, stream, cancellationToken).ConfigureAwait(false);
}
}
}
return info;
}
public static IEnumerable<string> GetAssemblyAttributes(IAssemblySymbol assemblySymbol)
{
var attributes = assemblySymbol.GetAttributes();
foreach (var attribute in attributes)
{
yield return attribute.ToString();
}
}
public ExternAliasRecord(string alias, IAssemblySymbol targetAssembly)
{
Debug.Assert(alias != null);
Debug.Assert(targetAssembly != null);
Alias = alias;
TargetAssembly = targetAssembly;
}
private static bool AssemblyHasPublicTypes(IAssemblySymbol assembly)
{
return assembly
.GlobalNamespace
.GetMembers()
.OfType<INamedTypeSymbol>()
.Where(s => s.DeclaredAccessibility == Accessibility.Public)
.Any();
}
private static bool IsOrUsesAssemblyType(ITypeSymbol typeSymbol, IAssemblySymbol assemblySymbol)
{
if (typeSymbol.ContainingAssembly == assemblySymbol)
{
return true;
}
INamedTypeSymbol namedTypeSymbol = typeSymbol as INamedTypeSymbol;
return namedTypeSymbol != null && namedTypeSymbol.IsGenericType
&& namedTypeSymbol.TypeArguments.Any(t => IsOrUsesAssemblyType(t, assemblySymbol));
}
public static bool IsObjectMapperFrameworkAssembly(IAssemblySymbol assemblySymbol)
{
if (assemblySymbol.Name != "ObjectMapper.Framework")
{
return false;
}
if (!assemblySymbol.Identity.IsStrongName || !_publicKeyToken.SequenceEqual(assemblySymbol.Identity.PublicKeyToken))
{
return false;
}
return true;
}
public MetadataSearchScope(
Solution solution,
IAssemblySymbol assembly,
PortableExecutableReference metadataReference,
bool ignoreCase,
CancellationToken cancellationToken)
: base(ignoreCase, cancellationToken)
{
_solution = solution;
_assembly = assembly;
_metadataReference = metadataReference;
}
internal static SymbolTreeInfo CreateSourceSymbolTreeInfo(
Solution solution, VersionStamp version, IAssemblySymbol assembly,
string filePath, CancellationToken cancellationToken)
{
if (assembly == null)
{
return null;
}
var unsortedNodes = new List<Node> { new Node(assembly.GlobalNamespace.Name, Node.RootNodeParentIndex) };
GenerateSourceNodes(assembly.GlobalNamespace, unsortedNodes, s_getMembersNoPrivate);
return CreateSymbolTreeInfo(solution, version, filePath, unsortedNodes);
}
public ImportRecord(
ImportTargetKind targetKind,
string alias = null,
ITypeSymbol targetType = null,
string targetString = null,
IAssemblySymbol targetAssembly = null,
string targetAssemblyAlias = null)
{
TargetKind = targetKind;
Alias = alias;
TargetType = targetType;
TargetString = targetString;
TargetAssembly = targetAssembly;
TargetAssemblyAlias = targetAssemblyAlias;
}
public IEnumerable<ISymbol> Find(IAssemblySymbol assembly, Func<string, bool> predicate, CancellationToken cancellationToken)
{
for (int i = 0, n = _nodes.Count; i < n; i++)
{
cancellationToken.ThrowIfCancellationRequested();
var node = _nodes[i];
if (predicate(node.Name))
{
foreach (var symbol in Bind(i, assembly.GlobalNamespace, cancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
yield return symbol;
}
}
}
}
/// <summary>
/// Get all symbols that have a name matching the specified name.
/// </summary>
public IEnumerable<ISymbol> Find(
IAssemblySymbol assembly,
string name,
bool ignoreCase,
CancellationToken cancellationToken)
{
var comparer = GetComparer(ignoreCase);
foreach (var node in FindNodes(name, comparer))
{
foreach (var symbol in Bind(node, assembly.GlobalNamespace, cancellationToken))
{
yield return symbol;
}
}
}
internal static SymbolTreeInfo CreateSourceSymbolTreeInfo(
Solution solution, VersionStamp version, IAssemblySymbol assembly,
string filePath, CancellationToken cancellationToken)
{
if (assembly == null)
{
return null;
}
var unsortedNodes = ArrayBuilder<BuilderNode>.GetInstance();
unsortedNodes.Add(new BuilderNode(assembly.GlobalNamespace.Name, RootNodeParentIndex));
GenerateSourceNodes(assembly.GlobalNamespace, unsortedNodes, s_getMembersNoPrivate);
return CreateSymbolTreeInfo(
solution, version, filePath, unsortedNodes.ToImmutableAndFree(),
inheritanceMap: new OrderPreservingMultiDictionary<string, string>());
}
public static string GetAssemblyDisplay(Compilation compilation, IAssemblySymbol assemblySymbol)
{
// This method is only used to generate a comment at the top of Metadata-as-Source documents and
// previous submissions are never viewed as metadata (i.e. we always have compilations) so there's no
// need to consume compilation.ScriptCompilationInfo.PreviousScriptCompilation.
// TODO (https://github.com/dotnet/roslyn/issues/6859): compilation.GetMetadataReference(assemblySymbol)?
var assemblyReference = compilation.References.Where(r =>
{
var referencedSymbol = compilation.GetAssemblyOrModuleSymbol(r) as IAssemblySymbol;
return
referencedSymbol != null &&
referencedSymbol.MetadataName == assemblySymbol.MetadataName;
})
.FirstOrDefault();
return assemblyReference?.Display ?? FeaturesResources.location_unknown;
}
/// <summary>
/// Get all symbols that have a name matching the specified name.
/// </summary>
public IEnumerable<ISymbol> Find(
IAssemblySymbol assembly,
string name,
bool ignoreCase,
CancellationToken cancellationToken)
{
// The node list is always ordered using StringComparer.InvariantCulture, which guarantees that upper and lower case
// symbols are adjacent in the order. Because of this, it is possible to also use StringComparer.InvariantCultureIgnoreCase on
// this same list, because all mixed cases equivalent strings will be contiguous.
var comparer = GetComparer(ignoreCase);
foreach (var node in FindNodes(name, comparer))
{
foreach (var symbol in Bind(node, assembly.GlobalNamespace, cancellationToken))
{
yield return symbol;
}
}
}
public static string GetAssemblyDisplay(Compilation compilation, IAssemblySymbol assemblySymbol)
{
var assemblyReference = compilation.References.Where(r =>
{
var referencedSymbol = compilation.GetAssemblyOrModuleSymbol(r) as IAssemblySymbol;
return
referencedSymbol != null &&
referencedSymbol.MetadataName == assemblySymbol.MetadataName;
})
.FirstOrDefault();
if (assemblyReference != null && assemblyReference.Display != null)
{
return assemblyReference.Display;
}
else
{
return FeaturesResources.LocationUnknown;
}
}
public IAssemblyReference Map(IAssemblySymbol assembly) {
Contract.Requires(assembly != null);
Contract.Ensures(Contract.Result<IAssemblyReference>() != null);
IAssemblyReference cciAssembly = null;
if (!assemblySymbolCache.TryGetValue(assembly, out cciAssembly)) {
var an = assembly.Identity;
IEnumerable<byte> pkt = an.PublicKeyToken.AsEnumerable();
if (pkt == null)
pkt = new byte[0];
var identity = new Microsoft.Cci.AssemblyIdentity(
this.nameTable.GetNameFor(an.Name),
an.CultureName == null ? "" : an.CultureName, // REVIEW: This can't be right
an.Version,
pkt,
"unknown://location" // BUGBUG an.Location == null ? "unknown://location" : an.Location
);
cciAssembly = new Microsoft.Cci.Immutable.AssemblyReference(this.host, identity);
assemblySymbolCache[assembly] = cciAssembly;
}
Contract.Assume(cciAssembly != null);
return cciAssembly;
}
public static bool IsOrContainsAccessibleAttribute(this ISymbol symbol, ISymbol withinType, IAssemblySymbol withinAssembly)
{
if (symbol is IAliasSymbol alias)
{
symbol = alias.Target;
}
var namespaceOrType = symbol as INamespaceOrTypeSymbol;
if (namespaceOrType == null)
{
return(false);
}
if (namespaceOrType.IsAttribute() && namespaceOrType.IsAccessibleWithin(withinType ?? withinAssembly))
{
return(true);
}
// PERF: Avoid allocating a lambda capture as this method is recursive
foreach (var namedType in namespaceOrType.GetTypeMembers())
{
if (namedType.IsOrContainsAccessibleAttribute(withinType, withinAssembly))
{
return(true);
}
}
return(false);
}
public virtual void VisitAssembly(IAssemblySymbol symbol)
{
DefaultVisit(symbol);
}
public override void WriteEndAssembly(IAssemblySymbol assemblySymbol)
{
DecreaseDepth();
}
private static async Task <Uri> GetAssemblyFullPathAsync(ISymbol symbol, Solution solution, CancellationToken cancellationToken)
{
IAssemblySymbol containingAssembly = GetContainingAssembly(symbol);
return(await GetAssemblyFullPathAsync(containingAssembly, solution, cancellationToken).ConfigureAwait(false));
}
public sealed override void VisitAssembly(IAssemblySymbol symbol)
{
throw ExceptionUtilities.UnexpectedValue(symbol.Kind);
}
public override object VisitAssembly(IAssemblySymbol assemblySymbol)
{
WriteType(SymbolKeyType.Assembly);
AssemblySymbolKey.Create(assemblySymbol, this);
return(null);
}
public RoslynMetadataExtractor(Compilation compilation, IAssemblySymbol assembly = null)
{
_compilation = compilation ?? throw new ArgumentNullException(nameof(compilation));
_assembly = assembly ?? compilation.Assembly;
}
/// <summary>
/// Adds given retargeting assembly for this compilation into the cache.
/// <see cref="CommonReferenceManager.SymbolCacheAndReferenceManagerStateGuard"/> must be locked while calling this method.
/// </summary>
internal void CacheRetargetingAssemblySymbolNoLock(IAssemblySymbol assembly)
{
_retargetingAssemblySymbols.Add(assembly);
}
public static bool IsSameAssemblyOrHasFriendAccessTo(this IAssemblySymbol assembly, IAssemblySymbol toAssembly)
{
return
(Equals(assembly, toAssembly) ||
(assembly.IsInteractive && toAssembly.IsInteractive) ||
toAssembly.GivesAccessTo(assembly));
}
public bool GivesAccessTo(IAssemblySymbol toAssembly)
{
throw new NotImplementedException();
}
public MappingEngine(SemanticModel semanticModel, SyntaxGenerator syntaxGenerator, IAssemblySymbol contextAssembly)
{
this.semanticModel = semanticModel;
this.syntaxGenerator = syntaxGenerator;
this.contextAssembly = contextAssembly;
}
/// <summary>
/// this gives you SymbolTreeInfo for a metadata
/// </summary>
public static async Task <SymbolTreeInfo> GetInfoForAssemblyAsync(Solution solution, IAssemblySymbol assembly, string filePath, CancellationToken cancellationToken)
{
SymbolTreeInfo info;
if (s_assemblyInfos.TryGetValue(assembly, out info))
{
return(info);
}
// IAssemblySymbol is immutable, even if we encounter a race, we might do same work twice but still will be correct.
// now, we can't use AsyncLazy here since constructing information requires a solution. if we ever get cancellation before
// finishing calculating, async lazy will hold onto solution graph until next call (if it ever gets called)
info = await LoadOrCreateAsync(solution, assembly, filePath, cancellationToken).ConfigureAwait(false);
return(s_assemblyInfos.GetValue(assembly, _ => info));
}
public static async Task <MappingEngine> Create(Document document, CancellationToken cancellationToken, IAssemblySymbol contextAssembly)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var syntaxGenerator = SyntaxGenerator.GetGenerator(document);
return(new MappingEngine(semanticModel, syntaxGenerator, contextAssembly));
}
internal static Symbol GetRuntimeMember(NamedTypeSymbol declaringType, ref MemberDescriptor descriptor, SignatureComparer <MethodSymbol, FieldSymbol, PropertySymbol, TypeSymbol, ParameterSymbol> comparer, IAssemblySymbol accessWithinOpt)
{
Symbol result = null;
SymbolKind targetSymbolKind;
MethodKind targetMethodKind = MethodKind.Ordinary;
bool isStatic = (descriptor.Flags & MemberFlags.Static) != 0;
switch (descriptor.Flags & MemberFlags.KindMask)
{
case MemberFlags.Constructor:
targetSymbolKind = SymbolKind.Method;
targetMethodKind = MethodKind.Constructor;
// static constructors are never called explicitly
Debug.Assert(!isStatic);
break;
case MemberFlags.Method:
targetSymbolKind = SymbolKind.Method;
break;
case MemberFlags.PropertyGet:
targetSymbolKind = SymbolKind.Method;
targetMethodKind = MethodKind.PropertyGet;
break;
case MemberFlags.Field:
targetSymbolKind = SymbolKind.Field;
break;
case MemberFlags.Property:
targetSymbolKind = SymbolKind.Property;
break;
default:
throw ExceptionUtilities.UnexpectedValue(descriptor.Flags);
}
foreach (var member in declaringType.GetMembers(descriptor.Name))
{
Debug.Assert(member.Name.Equals(descriptor.Name));
if (member.Kind != targetSymbolKind || member.IsStatic != isStatic || !(member.DeclaredAccessibility == Accessibility.Public))
{
continue;
}
switch (targetSymbolKind)
{
case SymbolKind.Method:
{
MethodSymbol method = (MethodSymbol)member;
MethodKind methodKind = method.MethodKind;
// Treat user-defined conversions and operators as ordinary methods for the purpose
// of matching them here.
if (methodKind == MethodKind.Conversion || methodKind == MethodKind.UserDefinedOperator)
{
methodKind = MethodKind.Ordinary;
}
if (method.Arity != descriptor.Arity || methodKind != targetMethodKind ||
((descriptor.Flags & MemberFlags.Virtual) != 0) != (method.IsVirtual || method.IsOverride || method.IsAbstract))
{
continue;
}
if (!comparer.MatchMethodSignature(method, descriptor.Signature))
{
continue;
}
}
break;
case SymbolKind.Property:
{
PropertySymbol property = (PropertySymbol)member;
if (((descriptor.Flags & MemberFlags.Virtual) != 0) != (property.IsVirtual || property.IsOverride || property.IsAbstract))
{
continue;
}
if (!comparer.MatchPropertySignature(property, descriptor.Signature))
{
continue;
}
}
break;
case SymbolKind.Field:
if (!comparer.MatchFieldSignature((FieldSymbol)member, descriptor.Signature))
{
continue;
}
break;
default:
throw ExceptionUtilities.UnexpectedValue(targetSymbolKind);
}
// ambiguity
if ((object)result != null)
{
result = null;
break;
}
result = member;
}
return(result);
}
internal abstract Cci.IAssemblyReference Translate(IAssemblySymbol symbol, DiagnosticBag diagnostics);
/// <inheritdoc/>
public override IEnumerable <ISymbol> VisitAssembly(IAssemblySymbol symbol)
{
return(symbol.GlobalNamespace.Accept(this));
}
public AssemblyWrapper(IAssemblySymbol assembly, MetadataLoadContextInternal metadataLoadContext)
{
Symbol = assembly;
_metadataLoadContext = metadataLoadContext;
}
public static bool HasReferenceToAssembly(this Project project, IAssemblySymbol assemblySymbol)
{
return(project.HasReferenceToAssembly(assemblySymbol.Name));
}
/// <summary>
/// this gives you SymbolTreeInfo for a metadata
/// </summary>
public static async Task<SymbolTreeInfo> GetInfoForAssemblyAsync(Solution solution, IAssemblySymbol assembly, string filePath, CancellationToken cancellationToken)
{
SymbolTreeInfo info;
if (s_assemblyInfos.TryGetValue(assembly, out info))
{
return info;
}
// IAssemblySymbol is immutable, even if we encounter a race, we might do same work twice but still will be correct.
// now, we can't use AsyncLazy here since constructing information requires a solution. if we ever get cancellation before
// finishing calculating, async lazy will hold onto solution graph until next call (if it ever gets called)
info = await LoadOrCreateAsync(solution, assembly, filePath, cancellationToken).ConfigureAwait(false);
return s_assemblyInfos.GetValue(assembly, _ => info);
}
private static async Task AddDeclarationsAsync(Project project, Compilation startingCompilation, IAssemblySymbol startingAssembly, string name, bool ignoreCase, SymbolFilter filter, List <ISymbol> list, CancellationToken cancellationToken)
{
Func <string, bool> predicate = n => ignoreCase?CaseInsensitiveComparison.Comparer.Equals(name, n) : StringComparer.Ordinal.Equals(name, n);
using (Logger.LogBlock(FunctionId.SymbolFinder_Project_AddDeclarationsAsync, cancellationToken))
using (var set = SharedPools.Default <HashSet <ISymbol> >().GetPooledObject())
{
if (!await project.ContainsSymbolsWithNameAsync(predicate, filter, cancellationToken).ConfigureAwait(false))
{
return;
}
var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
if ((startingCompilation != null) && (startingAssembly != null) && (compilation.Assembly != startingAssembly))
{
// Return symbols from skeleton assembly in this case so that symbols have the same language as startingCompilation.
list.AddRange(
FilterByCriteria(compilation.GetSymbolsWithName(predicate, filter, cancellationToken), filter)
.Select(s => s.GetSymbolKey().Resolve(startingCompilation, cancellationToken: cancellationToken).Symbol).WhereNotNull());
}
else
{
list.AddRange(FilterByCriteria(compilation.GetSymbolsWithName(predicate, filter, cancellationToken), filter));
}
}
}
/// <summary>
/// Gets the <see cref="MetadataReference"/> that corresponds to the assembly symbol.
/// </summary>
public new MetadataReference GetMetadataReference(IAssemblySymbol assemblySymbol)
{
return this.GetBoundReferenceManager().ReferencedAssembliesMap.Where(kvp => object.ReferenceEquals(kvp.Value.Symbol, assemblySymbol)).Select(kvp => kvp.Key).FirstOrDefault();
}
internal sealed override Cci.IAssemblyReference Translate(IAssemblySymbol symbol, DiagnosticBag diagnostics)
{
return(Translate((TAssemblySymbol)symbol, diagnostics));
}
private bool IsTagHelperAssembly(IAssemblySymbol assembly)
{
return(assembly.Name != null && !assembly.Name.StartsWith("System.", StringComparison.Ordinal));
}
public virtual TResult VisitAssembly(IAssemblySymbol symbol)
{
return(DefaultVisit(symbol));
}
public SymbolXmlDocumentation GetXmlDocumentation(ISymbol symbol, string preferredCultureName = null)
{
if (_symbolData.TryGetValue(symbol, out SymbolDocumentationData data) &&
data.XmlDocumentation != null)
{
if (object.ReferenceEquals(data.XmlDocumentation, SymbolXmlDocumentation.Default))
{
return(null);
}
return(data.XmlDocumentation);
}
IAssemblySymbol assembly = symbol.ContainingAssembly;
if (assembly != null)
{
SymbolXmlDocumentation xmlDocumentation = GetXmlDocumentation(assembly, preferredCultureName)?.GetXmlDocumentation(symbol);
if (xmlDocumentation != null)
{
_symbolData[symbol] = data.WithXmlDocumentation(xmlDocumentation);
return(xmlDocumentation);
}
CultureInfo preferredCulture = null;
if (preferredCultureName != null &&
!_cultures.TryGetValue(preferredCultureName, out preferredCulture))
{
preferredCulture = ImmutableInterlocked.GetOrAdd(ref _cultures, preferredCultureName, f => new CultureInfo(f));
}
string xml = symbol.GetDocumentationCommentXml(preferredCulture: preferredCulture, expandIncludes: true);
if (!string.IsNullOrEmpty(xml))
{
xml = XmlDocumentation.Unindent(xml);
if (!string.IsNullOrEmpty(xml))
{
var element = XElement.Parse(xml, LoadOptions.PreserveWhitespace);
xmlDocumentation = new SymbolXmlDocumentation(symbol, element);
_symbolData[symbol] = data.WithXmlDocumentation(xmlDocumentation);
return(xmlDocumentation);
}
}
}
if (!_additionalXmlDocumentationPaths.IsDefault)
{
if (_additionalXmlDocumentations.IsDefault)
{
_additionalXmlDocumentations = _additionalXmlDocumentationPaths
.Select(f => XmlDocumentation.Load(f))
.ToImmutableArray();
}
string commentId = symbol.GetDocumentationCommentId();
foreach (XmlDocumentation xmlDocumentation in _additionalXmlDocumentations)
{
SymbolXmlDocumentation documentation = xmlDocumentation.GetXmlDocumentation(symbol, commentId);
if (documentation != null)
{
_symbolData[symbol] = data.WithXmlDocumentation(documentation);
return(documentation);
}
}
}
_symbolData[symbol] = data.WithXmlDocumentation(SymbolXmlDocumentation.Default);
return(null);
}
internal override MetadataReference GetMetadataReference(IAssemblySymbol assemblySymbol) => _metadataMap.TryGetOrDefault(assemblySymbol);
public override void WriteStartAssembly(IAssemblySymbol assemblySymbol)
{
WriteIndentation();
}
/// <summary>
/// Maps given assembly symbol to an assembly ref.
/// </summary>
/// <remarks>
/// The compiler represents every submission by a compilation instance for which it creates a distinct source assembly symbol.
/// However multiple submissions might compile into a single dynamic assembly and so we need to map the corresponding assembly symbols to
/// the name of the dynamic assembly.
/// </remarks>
internal AssemblyIdentity MapAssemblySymbol(IAssemblySymbol symbol, bool collectible)
{
if (symbol.IsInteractive)
{
if (collectible)
{
// collectible assemblies can't reference other generated assemblies
throw ExceptionUtilities.Unreachable;
}
else if (!_uncollectibleCodeManager.ContainsAssembly(symbol.Identity.Name))
{
// uncollectible assemblies can reference uncollectible dynamic or uncollectible CCI generated assemblies:
return _uncollectibleCodeManager.dynamicAssemblyName;
}
}
return symbol.Identity;
}
public static bool IsSameAssemblyOrHasFriendAccessTo(this IAssemblySymbol assembly, IAssemblySymbol toAssembly)
{
var areEquals = assembly.Equals(toAssembly);
if (areEquals == false && toAssembly == null)
{
return(false);
}
return
(areEquals ||
(assembly.IsInteractive && toAssembly.IsInteractive) ||
toAssembly.GivesAccessTo(assembly));
}
/// <summary>
/// Get all symbols that have a matching name as determined by the predicate.
/// </summary>
public IEnumerable<ISymbol> Search(
IAssemblySymbol assembly,
Func<string, bool> predicate,
CancellationToken cancellationToken)
{
string lastName = null;
bool lastGood = false;
for (int i = 0; i < _nodes.Count; i++)
{
cancellationToken.ThrowIfCancellationRequested();
var node = _nodes[i];
var isSameName = (object)node.Name == (object)lastName;
if ((isSameName && lastGood) // check for same string instance to avoid invoking predicate when we already know the outcome (assumes no side effects of predicate.)
|| (!string.IsNullOrEmpty(node.Name) // don't consider unnamed things like the global namespace itself.
&& predicate(node.Name)))
{
lastGood = true;
// yield all symbols for this node
foreach (var symbol in Bind(i, assembly.GlobalNamespace, cancellationToken))
{
yield return symbol;
}
}
else
{
lastGood = false;
}
lastName = node.Name;
}
}
public override void VisitAssembly([NotNull] IAssemblySymbol symbol)
{
Visit(symbol.GlobalNamespace);
}
internal static SymbolTreeInfo Create(VersionStamp version, IAssemblySymbol assembly, CancellationToken cancellationToken)
{
if (assembly == null)
{
return null;
}
var list = new List<Node>();
GenerateNodes(assembly.GlobalNamespace, list);
return new SymbolTreeInfo(version, SortNodes(list));
}
internal abstract MetadataReference GetMetadataReference(IAssemblySymbol assemblySymbol);
public static void Create(IAssemblySymbol symbol, SymbolKeyWriter visitor)
{
// If the format of this ever changed, then it's necessary to fixup the
// SymbolKeyComparer.RemoveAssemblyKeys function.
visitor.WriteString(symbol.Identity.Name);
}
private Task <Tuple <MetadataItem, bool> > GetAssemblyMetadataFromCacheAsync(IEnumerable <string> files, Compilation compilation, IAssemblySymbol assembly, string outputFolder, bool forceRebuild, string filterConfigFile, IReadOnlyDictionary <Compilation, IEnumerable <IMethodSymbol> > extensionMethods)
{
if (files == null || !files.Any())
{
return(null);
}
return(GetMetadataFromProjectLevelCacheAsync(
files,
files.Concat(new string[] { filterConfigFile }), s => Task.FromResult(forceRebuild || s.AreFilesModified(files.Concat(new string[] { filterConfigFile }))),
s => Task.FromResult(compilation),
s => Task.FromResult(assembly),
s => null,
outputFolder,
false,
false,
filterConfigFile,
extensionMethods));
}
protected override MetadataReference CommonGetMetadataReference(IAssemblySymbol assemblySymbol)
{
var symbol = assemblySymbol as AssemblySymbol;
if ((object)symbol != null)
{
return this.GetMetadataReference(symbol);
}
else
{
return null;
}
}
// Is a protected symbol inside "originalContainingType" accessible from within "within",
// which much be a named type or an assembly.
private static bool IsProtectedSymbolAccessible(
INamedTypeSymbol withinType,
IAssemblySymbol withinAssembly,
ITypeSymbol throughTypeOpt,
INamedTypeSymbol originalContainingType,
out bool failedThroughTypeCheck)
{
failedThroughTypeCheck = false;
// It is not an error to define protected member in a sealed Script class,
// it's just a warning. The member behaves like a private one - it is visible
// in all subsequent submissions.
if (withinAssembly.IsInteractive && originalContainingType.IsScriptClass)
{
return(true);
}
if (withinType == null)
{
// If we're not within a type, we can't access a protected symbol
return(false);
}
// A protected symbol is accessible if we're (optionally nested) inside the type that it
// was defined in.
// NOTE(ericli): It is helpful to consider 'protected' as *increasing* the
// accessibility domain of a private member, rather than *decreasing* that of a public
// member. Members are naturally private; the protected, internal and public access
// modifiers all increase the accessibility domain. Since private members are accessible
// to nested types, so are protected members.
// NOTE(cyrusn): We do this check up front as it is very fast and easy to do.
if (IsNestedWithinOriginalContainingType(withinType, originalContainingType))
{
return(true);
}
// Protected is really confusing. Check out 3.5.3 of the language spec "protected access
// for instance members" to see how it works. I actually got the code for this from
// LangCompiler::CheckAccessCore
{
var current = withinType.OriginalDefinition;
var originalThroughTypeOpt = throughTypeOpt == null ? null : throughTypeOpt.OriginalDefinition;
while (current != null)
{
Contract.Requires(current.IsDefinition);
if (current.InheritsFromOrEqualsIgnoringConstruction(originalContainingType))
{
// NOTE(cyrusn): We're continually walking up the 'throughType's inheritance
// chain. We could compute it up front and cache it in a set. However, i
// don't want to allocate memory in this function. Also, in practice
// inheritance chains should be very short. As such, it might actually be
// slower to create and check inside the set versus just walking the
// inheritance chain.
if (originalThroughTypeOpt == null ||
originalThroughTypeOpt.InheritsFromOrEqualsIgnoringConstruction(current))
{
return(true);
}
else
{
failedThroughTypeCheck = true;
}
}
// NOTE(cyrusn): The container of an original type is always original.
current = current.ContainingType;
}
}
return(false);
}
