private async Task <Document> AddAssemblyInfoRegionAsync(Document document, Microsoft.CodeAnalysis.ISymbol symbol, CancellationToken cancellationToken)
{
var assemblyInfo = OmniSharpMetadataAsSourceHelpers.GetAssemblyInfo(symbol.ContainingAssembly);
var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
var assemblyPath = OmniSharpMetadataAsSourceHelpers.GetAssemblyDisplay(compilation, symbol.ContainingAssembly);
var regionTrivia = SyntaxFactory.RegionDirectiveTrivia(true)
.WithTrailingTrivia(new[] { SyntaxFactory.Space, SyntaxFactory.PreprocessingMessage(assemblyInfo) });
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var newRoot = oldRoot.WithLeadingTrivia(new[]
{
SyntaxFactory.Trivia(regionTrivia),
SyntaxFactory.CarriageReturnLineFeed,
SyntaxFactory.Comment("// " + assemblyPath),
SyntaxFactory.CarriageReturnLineFeed,
SyntaxFactory.Comment($"// Decompiled with ICSharpCode.Decompiler {decompilerVersion.FileVersion}"),
SyntaxFactory.CarriageReturnLineFeed,
SyntaxFactory.Trivia(SyntaxFactory.EndRegionDirectiveTrivia(true)),
SyntaxFactory.CarriageReturnLineFeed,
SyntaxFactory.CarriageReturnLineFeed
});
return(document.WithSyntaxRoot(newRoot));
}
public static ITypeSymbol InferAwaitableReturnType(this ISymbol symbol, SemanticModel semanticModel, int position)
{
var methodSymbol = symbol as IMethodSymbol;
if (methodSymbol == null)
{
return(null);
}
var returnType = methodSymbol.ReturnType;
if (returnType == null)
{
return(null);
}
var potentialGetAwaiters = semanticModel.LookupSymbols(position, container: returnType, name: WellKnownMemberNames.GetAwaiter, includeReducedExtensionMethods: true);
var getAwaiters = potentialGetAwaiters.OfType <IMethodSymbol>().Where(x => !x.Parameters.Any());
if (!getAwaiters.Any())
{
return(null);
}
var getResults = getAwaiters.SelectMany(g => semanticModel.LookupSymbols(position, container: g.ReturnType, name: WellKnownMemberNames.GetResult));
var getResult = getResults.OfType <IMethodSymbol>().FirstOrDefault(g => !g.IsStatic);
if (getResult == null)
{
return(null);
}
return(getResult.ReturnType);
}
static string GetSource(Microsoft.CodeAnalysis.ISymbol symbol)
{
switch (symbol.Kind)
{
case Microsoft.CodeAnalysis.SymbolKind.Alias:
case Microsoft.CodeAnalysis.SymbolKind.ArrayType:
case Microsoft.CodeAnalysis.SymbolKind.Assembly:
case Microsoft.CodeAnalysis.SymbolKind.DynamicType:
case Microsoft.CodeAnalysis.SymbolKind.ErrorType:
case Microsoft.CodeAnalysis.SymbolKind.Label:
case Microsoft.CodeAnalysis.SymbolKind.Local:
case Microsoft.CodeAnalysis.SymbolKind.NetModule:
case Microsoft.CodeAnalysis.SymbolKind.PointerType:
case Microsoft.CodeAnalysis.SymbolKind.Field:
case Microsoft.CodeAnalysis.SymbolKind.Parameter:
case Microsoft.CodeAnalysis.SymbolKind.RangeVariable:
case Microsoft.CodeAnalysis.SymbolKind.TypeParameter:
case Microsoft.CodeAnalysis.SymbolKind.Preprocessing:
return("field");
case Microsoft.CodeAnalysis.SymbolKind.NamedType:
var namedTypeSymbol = (Microsoft.CodeAnalysis.INamedTypeSymbol)symbol;
switch (namedTypeSymbol.TypeKind)
{
case Microsoft.CodeAnalysis.TypeKind.Class:
return("class");
case Microsoft.CodeAnalysis.TypeKind.Delegate:
return("delegate");
case Microsoft.CodeAnalysis.TypeKind.Enum:
return("enum");
case Microsoft.CodeAnalysis.TypeKind.Interface:
return("interface");
case Microsoft.CodeAnalysis.TypeKind.Struct:
return("struct");
default:
return("class");
}
case Microsoft.CodeAnalysis.SymbolKind.Method:
return("method");
case Microsoft.CodeAnalysis.SymbolKind.Namespace:
return("name-space");
case Microsoft.CodeAnalysis.SymbolKind.Property:
return("property");
case Microsoft.CodeAnalysis.SymbolKind.Event:
return("event");
default:
throw new ArgumentOutOfRangeException();
}
}
public static INamedTypeSymbol GetContainingTypeOrThis(this ISymbol symbol)
{
if (symbol is INamedTypeSymbol)
{
return((INamedTypeSymbol)symbol);
}
return(symbol.ContainingType);
}
public static ISymbol ConvertThisParameterToType(this ISymbol symbol)
{
if (symbol.IsThisParameter())
{
return(((IParameterSymbol)symbol).Type);
}
return(symbol);
}
// public static ImmutableArray<ISymbol> ExplicitInterfaceImplementations(this ISymbol symbol)
// {
// return symbol.TypeSwitch(
// (IEventSymbol @event) => @event.ExplicitInterfaceImplementations.As<ISymbol>(),
// (IMethodSymbol method) => method.ExplicitInterfaceImplementations.As<ISymbol>(),
// (IPropertySymbol property) => property.ExplicitInterfaceImplementations.As<ISymbol>(),
// _ => ImmutableArray.Create<ISymbol>());
// }
public static bool IsOverridable(this ISymbol symbol)
{
return
(symbol != null &&
symbol.ContainingType != null &&
symbol.ContainingType.TypeKind == TypeKind.Class &&
(symbol.IsVirtual || symbol.IsAbstract || symbol.IsOverride) &&
!symbol.IsSealed);
}
public static bool IsEventAccessor(this ISymbol symbol)
{
var method = symbol as IMethodSymbol;
return(method != null &&
(method.MethodKind == MethodKind.EventAdd ||
method.MethodKind == MethodKind.EventRaise ||
method.MethodKind == MethodKind.EventRemove));
}
public static bool IsNew(this ISymbol symbol)
{
switch (symbol.Kind)
{
case SymbolKind.Event:
{
var @event = symbol as IEventSymbol;
if (@event != null && (@event.ContainingType.BaseType != null && @event.ContainingType.BaseType.GetAllMembers().OfType <IEventSymbol>().Any(k => k.Name == @event.Name) && @event.IsOverride == false))
{
return(true);
}
}
break;
case SymbolKind.Method:
{
var @method = symbol as IMethodSymbol;
if (@method != null && (@method.ContainingType.BaseType != null && @method.ContainingType.BaseType.GetAllMembers().OfType <IMethodSymbol>().Any(k => MemberUtilities.CompareMethods(k, @method)) && @method.IsOverride == false))
{
return(true);
}
}
break;
case SymbolKind.Property:
{
var @property = symbol as IPropertySymbol;
if (@property != null && (@property.ContainingType.BaseType != null && @property.ContainingType.BaseType.GetAllMembers().OfType <IPropertySymbol>().Any(k => k.Name == @property.Name) && @property.IsOverride == false))
{
return(true);
}
}
break;
case SymbolKind.Field: // New Field is nothing special, base field
{
/* var @field = symbol as IFieldSymbol;
* if (@field != null && (@field.ContainingType.BaseType != null && @field.ContainingType.BaseType.GetAllMembers().OfType<IFieldSymbol>().Any(k => k.Name == @field.Name) && @field.IsOverride == false))
* {
* return true;
* }*/
return(false);
}
break;
}
return(false);
}
public static int GetArity(this ISymbol symbol)
{
switch (symbol.Kind)
{
case SymbolKind.NamedType:
return(((INamedTypeSymbol)symbol).Arity);
case SymbolKind.Method:
return(((IMethodSymbol)symbol).Arity);
default:
return(0);
}
}
public static ISymbol OverriddenMember(this ISymbol symbol)
{
switch (symbol.Kind)
{
case SymbolKind.Event:
return(((IEventSymbol)symbol).OverriddenEvent);
case SymbolKind.Method:
return(((IMethodSymbol)symbol).OverriddenMethod);
case SymbolKind.Property:
return(((IPropertySymbol)symbol).OverriddenProperty);
}
return(null);
}
public static Accessibility GetResultantVisibility(this ISymbol symbol)
{
// Start by assuming it's visible.
var visibility = Accessibility.Public;
switch (symbol.Kind)
{
case SymbolKind.Alias:
// Aliases are uber private. They're only visible in the same file that they
// were declared in.
return(Accessibility.Private);
case SymbolKind.Parameter:
// Parameters are only as visible as their containing symbol
return(GetResultantVisibility(symbol.ContainingSymbol));
case SymbolKind.TypeParameter:
// Type Parameters are private.
return(Accessibility.Private);
}
while (symbol != null && symbol.Kind != SymbolKind.Namespace)
{
switch (symbol.DeclaredAccessibility)
{
// If we see anything private, then the symbol is private.
case Accessibility.NotApplicable:
case Accessibility.Private:
return(Accessibility.Private);
// If we see anything internal, then knock it down from public to
// internal.
case Accessibility.Internal:
case Accessibility.ProtectedAndInternal:
visibility = Accessibility.Internal;
break;
// For anything else (Public, Protected, ProtectedOrInternal), the
// symbol stays at the level we've gotten so far.
}
symbol = symbol.ContainingSymbol;
}
return(visibility);
}
/// <returns>
/// Returns true if symbol is a local variable and its declaring syntax node is
/// after the current position, false otherwise (including for non-local symbols)
/// </returns>
public static bool IsInaccessibleLocal(this ISymbol symbol, int position)
{
if (symbol.Kind != SymbolKind.Local)
{
return(false);
}
// Implicitly declared locals (with Option Explicit Off in VB) are scoped to the entire
// method and should always be considered accessible from within the same method.
if (symbol.IsImplicitlyDeclared)
{
return(false);
}
var declarationSyntax = symbol.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).FirstOrDefault();
return(declarationSyntax != null && position < declarationSyntax.SpanStart);
}
public static ITypeSymbol GetMemberType(this ISymbol symbol)
{
switch (symbol.Kind)
{
case SymbolKind.Field:
return(((IFieldSymbol)symbol).Type);
case SymbolKind.Property:
return(((IPropertySymbol)symbol).Type);
case SymbolKind.Method:
return(((IMethodSymbol)symbol).ReturnType);
case SymbolKind.Event:
return(((IEventSymbol)symbol).Type);
}
return(null);
}
public static bool IsWriteableFieldOrProperty(this ISymbol symbol)
{
var fieldSymbol = symbol as IFieldSymbol;
if (fieldSymbol != null)
{
return(!fieldSymbol.IsReadOnly &&
!fieldSymbol.IsConst);
}
var propertySymbol = symbol as IPropertySymbol;
if (propertySymbol != null)
{
return(!propertySymbol.IsReadOnly);
}
return(false);
}
public static ISymbol GetOriginalUnreducedDefinition(this ISymbol symbol)
{
if (symbol.IsReducedExtension())
{
// note: ReducedFrom is only a method definition and includes no type arguments.
symbol = ((IMethodSymbol)symbol).GetConstructedReducedFrom();
}
if (symbol.IsFunctionValue())
{
var method = symbol.ContainingSymbol as IMethodSymbol;
if (method != null)
{
symbol = method;
if (method.AssociatedSymbol != null)
{
symbol = method.AssociatedSymbol;
}
}
}
if (symbol.IsNormalAnonymousType() || symbol.IsAnonymousTypeProperty())
{
return(symbol);
}
var parameter = symbol as IParameterSymbol;
if (parameter != null)
{
var method = parameter.ContainingSymbol as IMethodSymbol;
if (method.IsReducedExtension() == true)
{
symbol = method.GetConstructedReducedFrom().Parameters[parameter.Ordinal + 1];
}
}
return(symbol.OriginalDefinition);
}
// public static DeclarationModifiers GetSymbolModifiers(this ISymbol symbol)
// {
// return new DeclarationModifiers(
// isStatic: symbol.IsStatic,
// isAbstract: symbol.IsAbstract,
// isUnsafe: symbol.IsUnsafe(),
// isVirtual: symbol.IsVirtual,
// isOverride: symbol.IsOverride,
// isSealed: symbol.IsSealed);
// }
public static ITypeSymbol GetSymbolType(this ISymbol symbol)
{
var localSymbol = symbol as ILocalSymbol;
if (localSymbol != null)
{
return(localSymbol.Type);
}
var fieldSymbol = symbol as IFieldSymbol;
if (fieldSymbol != null)
{
return(fieldSymbol.Type);
}
var propertySymbol = symbol as IPropertySymbol;
if (propertySymbol != null)
{
return(propertySymbol.Type);
}
var parameterSymbol = symbol as IParameterSymbol;
if (parameterSymbol != null)
{
return(parameterSymbol.Type);
}
var aliasSymbol = symbol as IAliasSymbol;
if (aliasSymbol != null)
{
return(aliasSymbol.Target as ITypeSymbol);
}
return(symbol as ITypeSymbol);
}
public static Accessibility ComputeResultantAccessibility(this ISymbol symbol, ITypeSymbol finalDestination)
{
if (symbol == null)
{
return(Accessibility.Private);
}
switch (symbol.DeclaredAccessibility)
{
default:
return(symbol.DeclaredAccessibility);
case Accessibility.ProtectedAndInternal:
return(symbol.ContainingAssembly.GivesAccessTo(finalDestination.ContainingAssembly)
? Accessibility.ProtectedAndInternal
: Accessibility.Internal);
case Accessibility.ProtectedOrInternal:
return(symbol.ContainingAssembly.GivesAccessTo(finalDestination.ContainingAssembly)
? Accessibility.ProtectedOrInternal
: Accessibility.Protected);
}
}
public static bool IsOrContainsAccessibleAttribute(this ISymbol symbol, ISymbol withinType, IAssemblySymbol withinAssembly)
{
var alias = symbol as IAliasSymbol;
if (alias != null)
{
symbol = alias.Target;
}
var namespaceOrType = symbol as INamespaceOrTypeSymbol;
if (namespaceOrType == null)
{
return(false);
}
// if (namespaceOrType.IsAttribute() && namespaceOrType.IsAccessibleWithin(withinType ?? withinAssembly))
// {
// return true;
// }
return(namespaceOrType.GetMembers().Any(nt => nt.IsOrContainsAccessibleAttribute(withinType, withinAssembly)));
}
/// <summary>
/// If the <paramref name="symbol"/> is a method symbol, returns True if the method's return type is "awaitable".
/// If the <paramref name="symbol"/> is a type symbol, returns True if that type is "awaitable".
/// An "awaitable" is any type that exposes a GetAwaiter method which returns a valid "awaiter". This GetAwaiter method may be an instance method or an extension method.
/// </summary>
public static bool IsAwaitable(this ISymbol symbol, SemanticModel semanticModel, int position)
{
IMethodSymbol methodSymbol = symbol as IMethodSymbol;
ITypeSymbol typeSymbol = null;
if (methodSymbol == null)
{
typeSymbol = symbol as ITypeSymbol;
if (typeSymbol == null)
{
return(false);
}
}
else
{
if (methodSymbol.ReturnType == null)
{
return(false);
}
// dynamic
if (methodSymbol.ReturnType.TypeKind == TypeKind.Dynamic &&
methodSymbol.MethodKind != MethodKind.BuiltinOperator)
{
return(true);
}
}
// otherwise: needs valid GetAwaiter
var potentialGetAwaiters = semanticModel.LookupSymbols(position,
container: typeSymbol ?? methodSymbol.ReturnType.OriginalDefinition,
name: WellKnownMemberNames.GetAwaiter,
includeReducedExtensionMethods: true);
var getAwaiters = potentialGetAwaiters.OfType <IMethodSymbol>().Where(x => !x.Parameters.Any());
return(getAwaiters.Any(VerifyGetAwaiter));
}
public static bool IsImplementable(this ISymbol symbol)
{
if (symbol != null &&
symbol.ContainingType != null &&
symbol.ContainingType.TypeKind == TypeKind.Interface)
{
if (symbol.Kind == SymbolKind.Event)
{
return(true);
}
if (symbol.Kind == SymbolKind.Property)
{
return(true);
}
if (symbol.Kind == SymbolKind.Method && ((IMethodSymbol)symbol).MethodKind == MethodKind.Ordinary)
{
return(true);
}
}
return(false);
}
internal static async Task <long> GetLinesOfCodeAsync(ImmutableArray <SyntaxReference> declarations, ISymbol symbol, SemanticModelProvider semanticModelProvider, CancellationToken cancellationToken)
{
long linesOfCode = 0;
foreach (var decl in declarations)
{
SyntaxNode declSyntax = await GetTopmostSyntaxNodeForDeclarationAsync(decl, symbol, semanticModelProvider, cancellationToken).ConfigureAwait(false);
// For namespace symbols, don't count lines of code for declarations of child namespaces.
// For example, "namespace N1.N2 { }" is a declaration reference for N1, but the actual declaration is for N2.
if (symbol.Kind == SymbolKind.Namespace)
{
var model = semanticModelProvider.GetSemanticModel(declSyntax);
if (model.GetDeclaredSymbol(declSyntax, cancellationToken) != (object)symbol)
{
continue;
}
}
FileLinePositionSpan linePosition = declSyntax.SyntaxTree.GetLineSpan(declSyntax.FullSpan, cancellationToken);
long delta = linePosition.EndLinePosition.Line - linePosition.StartLinePosition.Line;
if (delta == 0)
{
// Declaration on a single line, we count it as a separate line.
delta = 1;
}
linesOfCode += delta;
}
return(linesOfCode);
}
internal static async Task <(int cyclomaticComplexity, ComputationalComplexityMetrics computationalComplexityMetrics)> ComputeCoupledTypesAndComplexityExcludingMemberDeclsAsync(
ImmutableArray <SyntaxReference> declarations,
ISymbol symbol,
ImmutableHashSet <INamedTypeSymbol> .Builder builder,
SemanticModelProvider semanticModelProvider,
CancellationToken cancellationToken)
{
int cyclomaticComplexity = 0;
ComputationalComplexityMetrics computationalComplexityMetrics = ComputationalComplexityMetrics.Default;
var nodesToProcess = new Queue <SyntaxNode>();
var applicableAttributeNodes = PooledHashSet <SyntaxNode> .GetInstance();
foreach (var declaration in declarations)
{
SyntaxNode syntax = await GetTopmostSyntaxNodeForDeclarationAsync(declaration, symbol, semanticModelProvider, cancellationToken).ConfigureAwait(false);
nodesToProcess.Enqueue(syntax);
// Ensure we process parameter initializers and attributes.
var parameters = GetParameters(symbol);
foreach (var parameter in parameters)
{
var parameterSyntaxRef = parameter.DeclaringSyntaxReferences.FirstOrDefault();
if (parameterSyntaxRef != null)
{
var parameterSyntax = await parameterSyntaxRef.GetSyntaxAsync(cancellationToken).ConfigureAwait(false);
nodesToProcess.Enqueue(parameterSyntax);
}
}
var attributes = symbol.GetAttributes();
if (symbol is IMethodSymbol methodSymbol)
{
attributes = attributes.AddRange(methodSymbol.GetReturnTypeAttributes());
}
foreach (var attribute in attributes)
{
if (attribute.ApplicationSyntaxReference != null &&
attribute.ApplicationSyntaxReference.SyntaxTree == declaration.SyntaxTree)
{
var attributeSyntax = await attribute.ApplicationSyntaxReference.GetSyntaxAsync(cancellationToken).ConfigureAwait(false);
if (applicableAttributeNodes.Add(attributeSyntax))
{
nodesToProcess.Enqueue(attributeSyntax);
}
}
}
do
{
var node = nodesToProcess.Dequeue();
var model = semanticModelProvider.GetSemanticModel(node);
if (!ReferenceEquals(node, syntax))
{
var declaredSymbol = model.GetDeclaredSymbol(node, cancellationToken);
if (declaredSymbol != null && !Equals(symbol, declaredSymbol) && declaredSymbol.Kind != SymbolKind.Parameter)
{
// Skip member declarations.
continue;
}
}
var typeInfo = model.GetTypeInfo(node, cancellationToken);
AddCoupledNamedTypesCore(builder, typeInfo.Type);
var operationBlock = model.GetOperation(node, cancellationToken);
if (operationBlock != null && operationBlock.Parent == null)
{
switch (operationBlock.Kind)
{
case OperationKind.Block:
case OperationKind.MethodBodyOperation:
case OperationKind.ConstructorBodyOperation:
cyclomaticComplexity += 1;
break;
case OperationKind.None:
// Skip non-applicable attributes.
if (!applicableAttributeNodes.Contains(node))
{
continue;
}
break;
}
computationalComplexityMetrics = computationalComplexityMetrics.Union(ComputationalComplexityMetrics.Compute(operationBlock));
// Add used types within executable code in the operation tree.
foreach (var operation in operationBlock.DescendantsAndSelf())
{
#if LEGACY_CODE_METRICS_MODE
// Legacy mode does not account for code within lambdas/local functions for code metrics.
if (operation.IsWithinLambdaOrLocalFunction())
{
continue;
}
#endif
if (!operation.IsImplicit && hasConditionalLogic(operation))
{
cyclomaticComplexity += 1;
}
AddCoupledNamedTypesCore(builder, operation.Type);
// Handle static member accesses specially as there is no operation for static type off which the member is accessed.
if (operation is IMemberReferenceOperation memberReference &&
memberReference.Member.IsStatic)
{
AddCoupledNamedTypesCore(builder, memberReference.Member.ContainingType);
}
else if (operation is IInvocationOperation invocation &&
(invocation.TargetMethod.IsStatic || invocation.TargetMethod.IsExtensionMethod))
{
AddCoupledNamedTypesCore(builder, invocation.TargetMethod.ContainingType);
}
}
}
public ProtocolCompletionData(ICompletionDataKeyHandler keyHandler, RoslynCodeCompletionFactory factory, int declarationBegin, ITypeSymbol currentType, Microsoft.CodeAnalysis.ISymbol member, bool afterKeyword) : base(keyHandler, factory, member, member.ToDisplayString())
{
this.afterKeyword = afterKeyword;
this.currentType = currentType;
this.declarationBegin = declarationBegin;
this.GenerateBody = true;
}
internal static async Task <SyntaxNode> GetTopmostSyntaxNodeForDeclarationAsync(SyntaxReference declaration, ISymbol declaredSymbol, SemanticModelProvider semanticModelProvider, CancellationToken cancellationToken)
{
var declSyntax = await declaration.GetSyntaxAsync(cancellationToken).ConfigureAwait(false);
if (declSyntax.Language == LanguageNames.VisualBasic)
{
SemanticModel model = semanticModelProvider.GetSemanticModel(declSyntax);
while (declSyntax.Parent != null && Equals(model.GetDeclaredSymbol(declSyntax.Parent, cancellationToken), declaredSymbol))
{
declSyntax = declSyntax.Parent;
}
}
return(declSyntax);
}
//
// public CSharpAmbience () : base ("C#")
// {
// }
//
// static Dictionary<TypeKind, string> classTypes = new Dictionary<TypeKind, string> ();
//
public override Task <MonoDevelop.Ide.CodeCompletion.TooltipInformation> GetTooltip(CancellationToken token, Microsoft.CodeAnalysis.ISymbol entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
return(SourceEditor.LanguageItemTooltipProvider.CreateTooltipInformation(token, null, null, entity, false, true));
}
public async Task <Document> AddSourceToAsync(Document document, Compilation symbolCompilation, Microsoft.CodeAnalysis.ISymbol symbol, CancellationToken cancellationToken)
{
// Get the name of the type the symbol is in
var containingOrThis = symbol.GetContainingTypeOrThis();
var fullName = GetFullReflectionName(containingOrThis);
var reference = symbolCompilation.GetMetadataReference(symbol.ContainingAssembly);
var assemblyLocation = (reference as PortableExecutableReference)?.FilePath;
if (assemblyLocation == null)
{
throw new NotSupportedException("Cannot_navigate_to_the_symbol_under_the_caret");
}
// Decompile
document = PerformDecompilation(document, fullName, symbolCompilation, assemblyLocation);
document = await AddAssemblyInfoRegionAsync(document, symbol, cancellationToken).ConfigureAwait(false);
// Convert XML doc comments to regular comments, just like MAS
document = await ConvertDocCommentsToRegularCommentsAsync(document, cancellationToken).ConfigureAwait(false);
var node = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
// Apply formatting rules
document = await Formatter.FormatAsync(
document, new[] { node.FullSpan },
options : null, cancellationToken).ConfigureAwait(false);
return(document);
}
internal static MonoDevelop.Ide.FindInFiles.SearchResult GetJumpTypePartSearchResult(Microsoft.CodeAnalysis.ISymbol part, Microsoft.CodeAnalysis.Location location)
{
var provider = new MonoDevelop.Ide.FindInFiles.FileProvider(location.SourceTree.FilePath);
var doc = TextEditorFactory.CreateNewDocument();
doc.Text = provider.ReadString().ReadToEnd();
int position = location.SourceSpan.Start;
while (position + part.Name.Length < doc.Length)
{
if (doc.GetTextAt(position, part.Name.Length) == part.Name)
{
break;
}
position++;
}
return(new MonoDevelop.Ide.FindInFiles.SearchResult(provider, position, part.Name.Length));
}
public AspAttributeCompletionData(Microsoft.CodeAnalysis.ISymbol member, string name = null)
: base(name ?? member.Name, member.GetStockIcon())
{
this.member = member;
}
public static bool IsOrContainsAccessibleAttribute(this ISymbol symbol, ISymbol withinType, IAssemblySymbol withinAssembly)
{
var alias = symbol as IAliasSymbol;
if (alias != null)
{
symbol = alias.Target;
}
var namespaceOrType = symbol as INamespaceOrTypeSymbol;
if (namespaceOrType == null)
{
return false;
}
// if (namespaceOrType.IsAttribute() && namespaceOrType.IsAccessibleWithin(withinType ?? withinAssembly))
// {
// return true;
// }
return namespaceOrType.GetMembers().Any(nt => nt.IsOrContainsAccessibleAttribute(withinType, withinAssembly));
}
public async Task <Document> AddSourceToAsync(Document document, Compilation symbolCompilation, Microsoft.CodeAnalysis.ISymbol symbol, CancellationToken cancellationToken)
{
// Get the name of the type the symbol is in
var containingOrThis = symbol.GetContainingTypeOrThis();
var fullName = GetFullReflectionName(containingOrThis);
string assemblyLocation = null;
var isReferenceAssembly = symbol.ContainingAssembly.GetAttributes().Any(attribute => attribute.AttributeClass.Name == nameof(ReferenceAssemblyAttribute) &&
attribute.AttributeClass.ToNameDisplayString() == typeof(ReferenceAssemblyAttribute).FullName);
if (isReferenceAssembly)
{
try
{
var fullAssemblyName = symbol.ContainingAssembly.Identity.GetDisplayName();
var globalAssemblyCacheType = typeof(ScriptOptions).Assembly.GetType("Microsoft.CodeAnalysis.GlobalAssemblyCache");
var instance = globalAssemblyCacheType.GetField("Instance", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null);
var args = new object[] { fullAssemblyName, assemblyLocation, null, CultureInfo.CurrentCulture };
instance.GetType().InvokeMember("ResolvePartialName", BindingFlags.InvokeMethod, Type.DefaultBinder, instance, args);
assemblyLocation = (string)args[1];
}
catch (Exception)
{
// log
}
}
if (assemblyLocation == null)
{
var reference = symbolCompilation.GetMetadataReference(symbol.ContainingAssembly);
assemblyLocation = (reference as PortableExecutableReference)?.FilePath;
if (assemblyLocation == null)
{
throw new NotSupportedException("Cannot_navigate_to_the_symbol_under_the_caret");
}
}
// Decompile
document = PerformDecompilation(document, fullName, symbolCompilation, assemblyLocation);
document = await AddAssemblyInfoRegionAsync(document, symbol, cancellationToken).ConfigureAwait(false);
// Convert XML doc comments to regular comments, just like MAS
var docCommentFormattingService = _csharpDocumentationCommentFormattingService.CreateInstance();
document = await ConvertDocCommentsToRegularCommentsAsync(document, docCommentFormattingService, cancellationToken).ConfigureAwait(false);
var node = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
// Apply formatting rules
document = await Formatter.FormatAsync(
document, new[] { node.FullSpan },
options : null, cancellationToken).ConfigureAwait(false);
return(document);
}
public static IconId GetStockIcon(this Microsoft.CodeAnalysis.ISymbol symbol)
{
return("md-" + GetAccess(symbol.DeclaredAccessibility) + GetGlobal(symbol) + GetSource(symbol));
}
public AspAttributeCompletionData (Microsoft.CodeAnalysis.ISymbol member, string name = null)
: base (name ?? member.Name, member.GetStockIcon ())
{
this.member = member;
}