public ICompletionData CreateTypeCompletionData(ICSharpCode.NRefactory.TypeSystem.IType type, bool fullName, bool isInAttributeContext)
{
string name = fullName ? builder.ConvertType(type).GetText() : type.Name;
if (isInAttributeContext && name.EndsWith("Attribute") && name.Length > "Attribute".Length)
{
name = name.Substring(0, name.Length - "Attribute".Length);
}
return(new CompletionData(name));
}
public override void VisitSimpleType(SimpleType simpleType)
{
TypeResolveResult rr;
if ((rr = simpleType.Annotation <TypeResolveResult>()) == null)
{
base.VisitSimpleType(simpleType);
return;
}
// HACK : ignore type names in attributes (TypeSystemAstBuilder doesn't handle them correctly)
if (simpleType.Parent is Syntax.Attribute)
{
base.VisitSimpleType(simpleType);
return;
}
astBuilder.NameLookupMode = simpleType.GetNameLookupMode();
if (astBuilder.NameLookupMode == NameLookupMode.Type)
{
AstType outermostType = simpleType;
while (outermostType.Parent is AstType)
{
outermostType = (AstType)outermostType.Parent;
}
if (outermostType.Parent is TypeReferenceExpression)
{
// ILSpy uses TypeReferenceExpression in expression context even when the C# parser
// wouldn't know that it's a type reference.
// Fall back to expression-mode lookup in these cases:
astBuilder.NameLookupMode = NameLookupMode.Expression;
}
}
simpleType.ReplaceWith(astBuilder.ConvertType(rr.Type));
}
public void ConvertType(IType type, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
AstType astType = astBuilder.ConvertType(type);
astType.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
}
protected string GetShortType(IType type)
{
if (builder == null)
{
var ctx = ext.CSharpUnresolvedFile.GetTypeResolveContext(ext.UnresolvedFileCompilation, ext.Document.Editor.Caret.Location) as CSharpTypeResolveContext;
var state = new CSharpResolver(ctx);
builder = new TypeSystemAstBuilder(state);
var dt = state.CurrentTypeDefinition;
var declaring = ctx.CurrentTypeDefinition != null ? ctx.CurrentTypeDefinition.DeclaringTypeDefinition : null;
if (declaring != null)
{
while (dt != null)
{
if (dt.Equals(declaring))
{
builder.AlwaysUseShortTypeNames = true;
break;
}
dt = dt.DeclaringTypeDefinition;
}
}
}
try {
return(GLib.Markup.EscapeText(builder.ConvertType(type).ToString(ext.FormattingPolicy.CreateOptions())));
} catch (Exception e) {
LoggingService.LogError("Exception while getting short type.", e);
return("");
}
}
public static AstType CreateShortType(BaseSemanticModel SemanticModel, IType expressionType, AstNode node)
{
var csResolver = SemanticModel.Resolver.GetResolverStateBefore(node);
var builder = new TypeSystemAstBuilder(csResolver);
return(builder.ConvertType(expressionType));
}
public EnumMemberCompletionData(IType enumType, IEntity member, TypeSystemAstBuilder builder) : base(enumType.Name + "." + member.Name)
{
this.enumType = enumType;
this.member = member;
this.Image = ClassBrowserIconService.Const;
this.CompletionText = builder.ConvertType(enumType).ToString() + "." + member.Name;
}
public static AstType CreateShortType(BaseRefactoringContext refactoringContext, IType expressionType, AstNode node)
{
var csResolver = refactoringContext.Resolver.GetResolverStateBefore(node);
var builder = new TypeSystemAstBuilder(csResolver);
return(builder.ConvertType(expressionType));
}
public override AstType CreateShortType(IType fullType)
{
AstNode node = Unit.GetNodeAt(Location);
CSharpResolver csResolver = resolver.GetResolverStateBefore(node);
var builder = new TypeSystemAstBuilder(csResolver);
return(builder.ConvertType(fullType));
}
ICompletionData ICompletionDataFactory.CreateTypeCompletionData(IType type, bool showFullName, bool isInAttributeContext, bool addForTypeCreation)
{
var data = new TypeCompletionData(type);
if (showFullName)
{
string text = builder.ConvertType(type).ToString();
data.CompletionText = text;
data.DisplayText = text;
}
if (isInAttributeContext)
{
data.CompletionText = StripAttributeSuffix(data.CompletionText);
data.DisplayText = StripAttributeSuffix(data.DisplayText);
}
return(data);
}
ICompletionData ICompletionDataFactory.CreateTypeCompletionData(IType type, bool showFullName, bool isInAttributeContext)
{
Lazy <string> displayText = new Lazy <string> (delegate {
string name = showFullName ? builder.ConvertType(type).GetText() : type.Name;
if (isInAttributeContext && name.EndsWith("Attribute") && name.Length > "Attribute".Length)
{
name = name.Substring(0, name.Length - "Attribute".Length);
}
return(name);
});
var result = new TypeCompletionData(type, ext,
displayText,
type.GetStockIcon());
return(result);
}
private void ConvertType(IType type, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
astBuilder.AlwaysUseShortTypeNames = true;
AstType astType = astBuilder.ConvertType(type);
astType.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
}
public void ConvertType(IType type, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedEntityNames) != ConversionFlags.UseFullyQualifiedEntityNames;
AstType astType = astBuilder.ConvertType(type);
astType.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
}
public string ConvertType(IType type)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
AstType astType = astBuilder.ConvertType(type);
CSharpFormattingOptions formatting = new CSharpFormattingOptions();
StringWriter writer = new StringWriter();
astType.AcceptVisitor(new CSharpOutputVisitor(writer, formatting), null);
return(writer.ToString());
}
static BlockStatement GenerateBodyFromContext(TypeSystemAstBuilder builder, DebuggerCompletionContext context)
{
var body = new BlockStatement();
foreach (var v in context.Variables)
{
body.Statements.Add(new VariableDeclarationStatement(builder.ConvertType(v.Type), v.Name));
}
body.Statements.Add(new ExpressionStatement(new IdentifierExpression("$__Caret_Point__$")));
return(body);
}
public override AstType CreateShortType(IType fullType)
{
CSharpResolver csResolver;
lock (resolver) {
csResolver = resolver.GetResolverStateBefore(GetNode());
}
var builder = new TypeSystemAstBuilder(csResolver);
return(builder.ConvertType(fullType));
}
public string ConvertType(IType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
AstType astType = astBuilder.ConvertType(type);
return(astType.GetText());
}
string TypeToStringInternal(IType t, bool includeNamespace, bool useBuiltinTypeNames = true, bool?isOutParameter = null)
{
TypeSystemAstBuilder builder = new TypeSystemAstBuilder();
builder.AlwaysUseShortTypeNames = !includeNamespace;
builder.AlwaysUseBuiltinTypeNames = useBuiltinTypeNames;
AstType astType = builder.ConvertType(t);
if (isOutParameter != null && astType is ComposedType ct && ct.HasRefSpecifier)
{
ct.HasRefSpecifier = false;
}
public MemberCompletionData(IType type, IEntity member, TypeSystemAstBuilder builder)
{
DeclarationCategory = DeclarationCategory.Enumeration_Member;
Type = type;
Member = member;
string typeName = builder.ConvertType(type).GetText();
SetDefaultText(typeName + "." + member.Name);
Documentation = member.Documentation;
}
public string ConvertType(IType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedEntityNames) != ConversionFlags.UseFullyQualifiedEntityNames;
AstType astType = astBuilder.ConvertType(type);
return(astType.ToString());
}
IEnumerable <CodeAction> GetActions(ParameterDeclaration parameter, IEnumerable <IType> possibleTypes)
{
var csResolver = ctx.Resolver.GetResolverStateBefore(parameter);
var astBuilder = new TypeSystemAstBuilder(csResolver);
foreach (var type in possibleTypes)
{
var localType = type;
var message = String.Format(ctx.TranslateString("Demote parameter to '{0}'"), type.FullName);
yield return(new CodeAction(message, script => {
script.Replace(parameter.Type, astBuilder.ConvertType(localType));
}, parameter.Type));
}
}
static string GeneratePartialClassContextStub(DebuggerCompletionContext context)
{
var compilation = SD.ParserService.GetCompilationForFile(context.FileName);
var file = SD.ParserService.GetExistingUnresolvedFile(context.FileName);
if (compilation == null || file == null)
{
return("");
}
var unresolvedMember = file.GetMember(context.Location);
if (unresolvedMember == null)
{
return("");
}
var member = unresolvedMember.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly));
if (member == null)
{
return("");
}
var builder = new TypeSystemAstBuilder();
MethodDeclaration decl;
if (unresolvedMember is IMethod)
{
// If it's a method, convert it directly (including parameters + type parameters)
decl = (MethodDeclaration)builder.ConvertEntity(member);
}
else
{
// Otherwise, create a method anyways, and copy the parameters
decl = new MethodDeclaration();
if (member is IParameterizedMember)
{
foreach (var p in ((IParameterizedMember)member).Parameters)
{
decl.Parameters.Add(builder.ConvertParameter(p));
}
}
}
decl.Name = "__DebuggerStub__";
decl.ReturnType = builder.ConvertType(member.ReturnType);
decl.Modifiers = unresolvedMember.IsStatic ? Modifiers.Static : Modifiers.None;
// Make the method look like an explicit interface implementation so that it doesn't appear in CC
decl.PrivateImplementationType = new SimpleType("__DummyType__");
decl.Body = GenerateBodyFromContext(builder, context);
return(WrapInType(unresolvedMember.DeclaringTypeDefinition, decl).ToString());
}
public ImportCompletionData(ITypeDefinition typeDef, CSharpResolver contextAtCaret, bool useFullName)
: base(typeDef)
{
this.Description = "using " + typeDef.Namespace + ";";
if (useFullName)
{
var astBuilder = new TypeSystemAstBuilder(contextAtCaret);
insertionText = astBuilder.ConvertType(typeDef).ToString();
}
else
{
insertionText = typeDef.Name;
insertUsing = typeDef.Namespace;
}
}
public TypeCompletionData(ICSharpCode.NRefactory.TypeSystem.IType type, bool fullName, bool isInAttributeContext, TypeSystemAstBuilder builder, bool addForTypeCreation)
{
Type = type;
FullName = fullName;
IsInAttributeContext = isInAttributeContext;
// Confirm that this doesn't also include other types, such as enums, structs, etc.
//DeclarationCategory = DeclarationCategory.Class;
DeclarationCategory = type.Kind.ResolveDeclarationCategoryFromTypeKind();
string typeName = fullName ? builder.ConvertType(type).GetText() : type.Name;
if (isInAttributeContext && typeName.EndsWith("Attribute") && typeName.Length > "Attribute".Length)
{
typeName = typeName.Substring(0, typeName.Length - "Attribute".Length);
}
SetDefaultText(typeName);
// for documentation, see type.GetDefinition().Documentation
Documentation = type.GetDefinition().Documentation;
}
public override void VisitForeachStatement(ForeachStatement foreachStatement)
{
base.VisitForeachStatement(foreachStatement);
var rr = ctx.Resolve(foreachStatement) as ForEachResolveResult;
if (rr == null)
{
return;
}
if (rr.ElementType.Kind == TypeKind.Unknown || rr.ElementVariable.Type.Kind == TypeKind.Unknown)
{
return;
}
if (ReflectionHelper.GetTypeCode(rr.ElementType) == TypeCode.Object)
{
return;
}
if (conversions == null)
{
conversions = CSharpConversions.Get(ctx.Compilation);
}
Conversion c = conversions.ImplicitConversion(rr.ElementType, rr.ElementVariable.Type);
if (c.IsValid)
{
return;
}
var csResolver = ctx.GetResolverStateBefore(foreachStatement);
var builder = new TypeSystemAstBuilder(csResolver);
AstType elementType = builder.ConvertType(rr.ElementType);
AstType variableType = foreachStatement.VariableType;
string issueText = ctx.TranslateString("Collection element type '{0}' is not implicitly convertible to '{1}'");
string fixText = ctx.TranslateString("Use type '{0}'");
AddDiagnosticAnalyzer(new CodeIssue(variableType, string.Format(issueText, elementType.ToString(), variableType.ToString()),
new CodeAction(
string.Format(fixText, elementType.ToString()),
script => script.Replace(variableType, elementType),
foreachStatement)));
}
static string TypeToStringInternal(IType t, bool includeNamespace, bool useBuiltinTypeNames = true, ParameterModifier parameterModifier = ParameterModifier.None)
{
TypeSystemAstBuilder builder = new TypeSystemAstBuilder();
builder.AlwaysUseShortTypeNames = !includeNamespace;
builder.UseKeywordsForBuiltinTypes = useBuiltinTypeNames;
const ParameterModifier refInOutModifier = ParameterModifier.Ref | ParameterModifier.Out | ParameterModifier.In;
AstType astType = builder.ConvertType(t);
if ((parameterModifier & refInOutModifier) != 0 && astType is ComposedType ct && ct.HasRefSpecifier)
{
ct.HasRefSpecifier = false;
}
StringWriter w = new StringWriter();
astType.AcceptVisitor(new CSharpOutputVisitor(w, TypeToStringFormattingOptions));
string output = w.ToString();
switch (parameterModifier)
{
case ParameterModifier.Ref:
output = "ref " + output;
break;
case ParameterModifier.Out:
output = "out " + output;
break;
case ParameterModifier.In:
output = "in " + output;
break;
}
return(output);
}
static string GeneratePartialClassContextStub(ICodeContext context)
{
var member = context.CurrentMember;
if (member == null)
{
return("");
}
var builder = new TypeSystemAstBuilder();
MethodDeclaration decl;
if (member is IMethod)
{
// If it's a method, convert it directly (including parameters + type parameters)
decl = (MethodDeclaration)builder.ConvertEntity(member);
}
else
{
// Otherwise, create a method anyways, and copy the parameters
decl = new MethodDeclaration();
if (member is IParameterizedMember)
{
foreach (var p in ((IParameterizedMember)member).Parameters)
{
decl.Parameters.Add(builder.ConvertParameter(p));
}
}
}
decl.Name = "__DebuggerStub__";
decl.ReturnType = builder.ConvertType(member.ReturnType);
decl.Modifiers = member.IsStatic ? Modifiers.Static : Modifiers.None;
// Make the method look like an explicit interface implementation so that it doesn't appear in CC
decl.PrivateImplementationType = new SimpleType("__DummyType__");
decl.Body = GenerateBodyFromContext(builder, context.LocalVariables.ToArray());
return(WrapInType(context.CurrentTypeDefinition, decl).ToString());
}
public ICompletionData CreateMemberCompletionData(IType type, IEntity member)
{
string name = builder.ConvertType(type).ToString();
return(new EntityCompletionData(member, name + "." + member.Name));
}
static IEnumerable <Tuple <string, bool> > GetPossibleNamespaces(Document doc, AstNode node, ResolveResult resolveResult, DocumentLocation location)
{
var unit = doc.ParsedDocument.GetAst <SyntaxTree> ();
if (unit == null)
{
yield break;
}
int tc = GetTypeParameterCount(node);
var attribute = unit.GetNodeAt <ICSharpCode.NRefactory.CSharp.Attribute> (location);
bool isInsideAttributeType = attribute != null && attribute.Type.Contains(location);
var compilation = doc.Compilation;
var lookup = new MemberLookup(null, compilation.MainAssembly);
if (resolveResult is AmbiguousTypeResolveResult)
{
var aResult = resolveResult as AmbiguousTypeResolveResult;
var file = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
var scope = file.GetUsingScope(location).Resolve(compilation);
while (scope != null)
{
foreach (var u in scope.Usings)
{
foreach (var typeDefinition in u.Types)
{
if (typeDefinition.Name == aResult.Type.Name &&
typeDefinition.TypeParameterCount == tc &&
lookup.IsAccessible(typeDefinition, false))
{
yield return(Tuple.Create(typeDefinition.Namespace, true));
}
}
}
scope = scope.Parent;
}
yield break;
}
if (resolveResult is UnknownIdentifierResolveResult)
{
var uiResult = resolveResult as UnknownIdentifierResolveResult;
string possibleAttributeName = isInsideAttributeType ? uiResult.Identifier + "Attribute" : null;
foreach (var typeDefinition in compilation.GetAllTypeDefinitions())
{
if ((typeDefinition.Name == uiResult.Identifier || typeDefinition.Name == possibleAttributeName) && typeDefinition.TypeParameterCount == tc &&
lookup.IsAccessible(typeDefinition, false))
{
if (typeDefinition.DeclaringTypeDefinition != null)
{
var builder = new TypeSystemAstBuilder(new CSharpResolver(doc.Compilation));
yield return(Tuple.Create(builder.ConvertType(typeDefinition.DeclaringTypeDefinition).ToString(), false));
}
else
{
yield return(Tuple.Create(typeDefinition.Namespace, true));
}
}
}
yield break;
}
if (resolveResult is UnknownMemberResolveResult)
{
var umResult = (UnknownMemberResolveResult)resolveResult;
string possibleAttributeName = isInsideAttributeType ? umResult.MemberName + "Attribute" : null;
foreach (var typeDefinition in compilation.GetAllTypeDefinitions().Where(t => t.HasExtensionMethods))
{
foreach (var method in typeDefinition.Methods.Where(m => m.IsExtensionMethod && (m.Name == umResult.MemberName || m.Name == possibleAttributeName)))
{
IType[] inferredTypes;
if (CSharpResolver.IsEligibleExtensionMethod(
compilation.Import(umResult.TargetType),
method,
true,
out inferredTypes
))
{
yield return(Tuple.Create(typeDefinition.Namespace, true));
goto skipType;
}
}
skipType:
;
}
yield break;
}
if (resolveResult is ErrorResolveResult)
{
var identifier = unit != null?unit.GetNodeAt <Identifier> (location) : null;
if (identifier != null)
{
var uiResult = resolveResult as UnknownIdentifierResolveResult;
if (uiResult != null)
{
string possibleAttributeName = isInsideAttributeType ? uiResult.Identifier + "Attribute" : null;
foreach (var typeDefinition in compilation.GetAllTypeDefinitions())
{
if ((identifier.Name == uiResult.Identifier || identifier.Name == possibleAttributeName) &&
typeDefinition.TypeParameterCount == tc &&
lookup.IsAccessible(typeDefinition, false))
{
yield return(Tuple.Create(typeDefinition.Namespace, true));
}
}
}
}
yield break;
}
}
static IEnumerable <PossibleNamespace> GetPossibleNamespaces(Document doc, AstNode node, ResolveResult resolveResult, DocumentLocation location)
{
var unit = doc.ParsedDocument.GetAst <SyntaxTree> ();
if (unit == null)
{
yield break;
}
var project = doc.Project;
if (project == null)
{
yield break;
}
int tc = GetTypeParameterCount(node);
var attribute = unit.GetNodeAt <ICSharpCode.NRefactory.CSharp.Attribute> (location);
bool isInsideAttributeType = attribute != null && attribute.Type.Contains(location);
var compilations = new List <Tuple <ICompilation, MonoDevelop.Projects.ProjectReference> > ();
compilations.Add(Tuple.Create(doc.Compilation, (MonoDevelop.Projects.ProjectReference)null));
var referencedItems = IdeApp.Workspace != null?project.GetReferencedItems(IdeApp.Workspace.ActiveConfiguration).ToList() : (IEnumerable <SolutionItem>) new SolutionItem[0];
var solution = project != null ? project.ParentSolution : null;
if (solution != null)
{
foreach (var curProject in solution.GetAllProjects())
{
if (curProject == project || referencedItems.Contains(curProject))
{
continue;
}
var comp = TypeSystemService.GetCompilation(curProject);
if (comp == null)
{
continue;
}
compilations.Add(Tuple.Create(comp, new MonoDevelop.Projects.ProjectReference(curProject)));
}
}
var netProject = project as DotNetProject;
if (netProject == null)
{
yield break;
}
var frameworkLookup = TypeSystemService.GetFrameworkLookup(netProject);
if (resolveResult is UnknownMemberResolveResult)
{
var umResult = (UnknownMemberResolveResult)resolveResult;
foreach (var r in frameworkLookup.LookupExtensionMethod(umResult.MemberName))
{
var systemAssembly = netProject.AssemblyContext.GetAssemblyFromFullName(r.FullName, r.Package, netProject.TargetFramework);
if (systemAssembly == null)
{
continue;
}
compilations.Add(Tuple.Create(TypeSystemService.GetCompilation(systemAssembly, doc.Compilation), new MonoDevelop.Projects.ProjectReference(systemAssembly)));
}
}
bool foundIdentifier = false;
var lookup = new MemberLookup(null, doc.Compilation.MainAssembly);
foreach (var comp in compilations)
{
var compilation = comp.Item1;
var requiredReference = comp.Item2;
if (resolveResult is AmbiguousTypeResolveResult)
{
if (compilation != doc.Compilation)
{
continue;
}
var aResult = resolveResult as AmbiguousTypeResolveResult;
var file = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
var scope = file.GetUsingScope(location).Resolve(compilation);
while (scope != null)
{
foreach (var u in scope.Usings)
{
foreach (var typeDefinition in u.Types)
{
if (typeDefinition.Name == aResult.Type.Name &&
typeDefinition.TypeParameterCount == tc &&
lookup.IsAccessible(typeDefinition, false))
{
yield return(new PossibleNamespace(typeDefinition.Namespace, true, requiredReference));
}
}
}
scope = scope.Parent;
}
}
var allTypes = compilation == doc.Compilation ? compilation.GetAllTypeDefinitions() : compilation.MainAssembly.GetAllTypeDefinitions();
if (resolveResult is UnknownIdentifierResolveResult)
{
var uiResult = resolveResult as UnknownIdentifierResolveResult;
string possibleAttributeName = isInsideAttributeType ? uiResult.Identifier + "Attribute" : uiResult.Identifier;
foreach (var typeDefinition in allTypes)
{
if (typeDefinition.Name == possibleAttributeName && typeDefinition.TypeParameterCount == tc &&
lookup.IsAccessible(typeDefinition, false))
{
if (typeDefinition.DeclaringTypeDefinition != null)
{
var builder = new TypeSystemAstBuilder(new CSharpResolver(doc.Compilation));
foundIdentifier = true;
yield return(new PossibleNamespace(builder.ConvertType(typeDefinition.DeclaringTypeDefinition).ToString(), false, requiredReference));
}
else
{
foundIdentifier = true;
yield return(new PossibleNamespace(typeDefinition.Namespace, true, requiredReference));
}
}
}
}
if (resolveResult is UnknownMemberResolveResult)
{
var umResult = (UnknownMemberResolveResult)resolveResult;
string possibleAttributeName = isInsideAttributeType ? umResult.MemberName + "Attribute" : umResult.MemberName;
foreach (var typeDefinition in allTypes.Where(t => t.HasExtensionMethods))
{
foreach (var method in typeDefinition.Methods.Where(m => m.IsExtensionMethod && m.Name == possibleAttributeName))
{
IType[] inferredTypes;
if (CSharpResolver.IsEligibleExtensionMethod(
compilation.Import(umResult.TargetType),
method,
true,
out inferredTypes
))
{
yield return(new PossibleNamespace(typeDefinition.Namespace, true, requiredReference));
goto skipType;
}
}
skipType:
;
}
}
if (resolveResult is ErrorResolveResult)
{
var identifier = unit != null?unit.GetNodeAt <Identifier> (location) : null;
if (identifier != null)
{
var uiResult = resolveResult as UnknownIdentifierResolveResult;
if (uiResult != null)
{
string possibleAttributeName = isInsideAttributeType ? uiResult.Identifier + "Attribute" : uiResult.Identifier;
foreach (var typeDefinition in allTypes)
{
if ((identifier.Name == possibleAttributeName) &&
typeDefinition.TypeParameterCount == tc &&
lookup.IsAccessible(typeDefinition, false))
{
yield return(new PossibleNamespace(typeDefinition.Namespace, true, requiredReference));
}
}
}
}
}
}
// Try to search framework types
if (!foundIdentifier && resolveResult is UnknownIdentifierResolveResult)
{
var uiResult = resolveResult as UnknownIdentifierResolveResult;
string possibleAttributeName = isInsideAttributeType ? uiResult.Identifier + "Attribute" : uiResult.Identifier;
foreach (var r in frameworkLookup.LookupIdentifier(possibleAttributeName, tc))
{
var systemAssembly = netProject.AssemblyContext.GetAssemblyFromFullName(r.FullName, r.Package, netProject.TargetFramework);
if (systemAssembly == null)
{
continue;
}
yield return(new PossibleNamespace(r.Namespace, true, new MonoDevelop.Projects.ProjectReference(systemAssembly)));
}
}
}
public void ConvertSymbol(ISymbol symbol, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
{
if (symbol == null)
{
throw new ArgumentNullException(nameof(symbol));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (formattingPolicy == null)
{
throw new ArgumentNullException(nameof(formattingPolicy));
}
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
AstNode node = astBuilder.ConvertSymbol(symbol);
writer.StartNode(node);
EntityDeclaration entityDecl = node as EntityDeclaration;
if (entityDecl != null)
{
PrintModifiers(entityDecl.Modifiers, writer);
}
if ((ConversionFlags & ConversionFlags.ShowDefinitionKeyword) == ConversionFlags.ShowDefinitionKeyword)
{
if (node is TypeDeclaration)
{
switch (((TypeDeclaration)node).ClassType)
{
case ClassType.Class:
writer.WriteKeyword(Roles.ClassKeyword, "class");
break;
case ClassType.Struct:
writer.WriteKeyword(Roles.StructKeyword, "struct");
break;
case ClassType.Interface:
writer.WriteKeyword(Roles.InterfaceKeyword, "interface");
break;
case ClassType.Enum:
writer.WriteKeyword(Roles.EnumKeyword, "enum");
break;
case ClassType.RecordClass:
writer.WriteKeyword(Roles.RecordKeyword, "record");
break;
default:
throw new Exception("Invalid value for ClassType");
}
writer.Space();
}
else if (node is DelegateDeclaration)
{
writer.WriteKeyword(Roles.DelegateKeyword, "delegate");
writer.Space();
}
else if (node is EventDeclaration)
{
writer.WriteKeyword(EventDeclaration.EventKeywordRole, "event");
writer.Space();
}
else if (node is NamespaceDeclaration)
{
writer.WriteKeyword(Roles.NamespaceKeyword, "namespace");
writer.Space();
}
}
if ((ConversionFlags & ConversionFlags.PlaceReturnTypeAfterParameterList) != ConversionFlags.PlaceReturnTypeAfterParameterList &&
(ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType)
{
var rt = node.GetChildByRole(Roles.Type);
if (!rt.IsNull)
{
rt.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
writer.Space();
}
}
if (symbol is ITypeDefinition)
{
WriteTypeDeclarationName((ITypeDefinition)symbol, writer, formattingPolicy);
}
else if (symbol is IMember)
{
WriteMemberDeclarationName((IMember)symbol, writer, formattingPolicy);
}
else
{
writer.WriteIdentifier(Identifier.Create(symbol.Name));
}
if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList && HasParameters(symbol))
{
writer.WriteToken(symbol.SymbolKind == SymbolKind.Indexer ? Roles.LBracket : Roles.LPar, symbol.SymbolKind == SymbolKind.Indexer ? "[" : "(");
bool first = true;
foreach (var param in node.GetChildrenByRole(Roles.Parameter))
{
if ((ConversionFlags & ConversionFlags.ShowParameterModifiers) == 0)
{
param.ParameterModifier = ParameterModifier.None;
}
if ((ConversionFlags & ConversionFlags.ShowParameterDefaultValues) == 0)
{
param.DefaultExpression.Detach();
}
if (first)
{
first = false;
}
else
{
writer.WriteToken(Roles.Comma, ",");
writer.Space();
}
param.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
}
writer.WriteToken(symbol.SymbolKind == SymbolKind.Indexer ? Roles.RBracket : Roles.RPar, symbol.SymbolKind == SymbolKind.Indexer ? "]" : ")");
}
if ((ConversionFlags & ConversionFlags.PlaceReturnTypeAfterParameterList) == ConversionFlags.PlaceReturnTypeAfterParameterList &&
(ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType)
{
var rt = node.GetChildByRole(Roles.Type);
if (!rt.IsNull)
{
writer.Space();
writer.WriteToken(Roles.Colon, ":");
writer.Space();
if (symbol is IField f && CSharpDecompiler.IsFixedField(f, out var type, out int elementCount))
{
rt = astBuilder.ConvertType(type);
new IndexerExpression(new TypeReferenceExpression(rt), astBuilder.ConvertConstantValue(f.Compilation.FindType(KnownTypeCode.Int32), elementCount))
.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
}
else
{
rt.AcceptVisitor(new CSharpOutputVisitor(writer, formattingPolicy));
}
}
}
