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 string ConvertVariable(IVariable v)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
AstNode astNode = astBuilder.ConvertVariable(v);
return(astNode.ToString().TrimEnd(';', '\r', '\n'));
}
public void ConvertType(IType type, TextWriterTokenWriter formatter, CSharpFormattingOptions formattingPolicy)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
AstType astType = astBuilder.ConvertType(type);
astType.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
}
public FullyQualifyAmbiguousTypeNamesVisitor(TransformContext context, UsingScope usingScope)
{
this.ignoreUsingScope = !context.Settings.UsingDeclarations;
CSharpTypeResolveContext currentContext;
if (ignoreUsingScope)
{
currentContext = new CSharpTypeResolveContext(context.TypeSystem.MainModule);
}
else
{
this.context = new Stack <CSharpTypeResolveContext>();
if (!string.IsNullOrEmpty(context.CurrentTypeDefinition?.Namespace))
{
foreach (string ns in context.CurrentTypeDefinition.Namespace.Split('.'))
{
usingScope = new UsingScope(usingScope, ns);
}
}
currentContext = new CSharpTypeResolveContext(context.TypeSystem.MainModule, usingScope.Resolve(context.TypeSystem), context.CurrentTypeDefinition);
this.context.Push(currentContext);
}
this.astBuilder = CreateAstBuilder(currentContext);
}
public override void VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration)
{
if (ignoreUsingScope)
{
base.VisitNamespaceDeclaration(namespaceDeclaration);
return;
}
var previousContext = context.Peek();
var usingScope = previousContext.CurrentUsingScope.UnresolvedUsingScope;
foreach (string ident in namespaceDeclaration.Identifiers)
{
usingScope = new UsingScope(usingScope, ident);
}
var currentContext = new CSharpTypeResolveContext(previousContext.CurrentModule, usingScope.Resolve(previousContext.Compilation));
context.Push(currentContext);
try {
astBuilder = CreateAstBuilder(currentContext);
base.VisitNamespaceDeclaration(namespaceDeclaration);
} finally {
astBuilder = CreateAstBuilder(previousContext);
context.Pop();
}
}
void Visit <T>(T entityDeclaration, Action <T> baseCall) where T : EntityDeclaration
{
if (ignoreUsingScope)
{
baseCall(entityDeclaration);
return;
}
if (entityDeclaration.GetSymbol() is IMethod method)
{
var previousContext = context.Peek();
CSharpTypeResolveContext currentContext;
if (CSharpDecompiler.IsWindowsFormsInitializeComponentMethod(method))
{
currentContext = new CSharpTypeResolveContext(previousContext.CurrentModule);
}
else
{
currentContext = previousContext.WithCurrentMember(method);
}
context.Push(currentContext);
try {
var function = entityDeclaration.Annotation <IL.ILFunction>();
astBuilder = CreateAstBuilder(currentContext, function);
baseCall(entityDeclaration);
} finally {
astBuilder = CreateAstBuilder(previousContext);
context.Pop();
}
}
else
{
baseCall(entityDeclaration);
}
}
void ConvertTypeDeclaration(ITypeDefinition typeDef, StringWriter writer)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
TypeDeclaration typeDeclaration = (TypeDeclaration)astBuilder.ConvertEntity(typeDef);
PrintModifiers(typeDeclaration.Modifiers, writer);
if ((ConversionFlags & ConversionFlags.ShowDefinitionKeyWord) == ConversionFlags.ShowDefinitionKeyWord)
{
switch (typeDeclaration.ClassType)
{
case ClassType.Class:
writer.Write("class");
break;
case ClassType.Struct:
writer.Write("struct");
break;
case ClassType.Interface:
writer.Write("interface");
break;
case ClassType.Enum:
writer.Write("enum");
break;
default:
throw new Exception("Invalid value for ClassType");
}
writer.Write(' ');
}
WriteTypeDeclarationName(typeDef, writer);
}
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("");
}
}
void WriteTypeDeclarationName(ITypeDefinition typeDef, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
EntityDeclaration node = astBuilder.ConvertEntity(typeDef);
if (typeDef.DeclaringTypeDefinition != null)
{
WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, writer, formattingPolicy);
writer.WriteTokenOperator(Roles.Dot, ".");
}
else if ((ConversionFlags & ConversionFlags.UseFullyQualifiedEntityNames) == ConversionFlags.UseFullyQualifiedEntityNames)
{
if (!string.IsNullOrEmpty(typeDef.Namespace))
{
WriteQualifiedName(typeDef.Namespace, writer, formattingPolicy);
writer.WriteTokenOperator(Roles.Dot, ".");
}
}
writer.WriteIdentifier(node.NameToken, BoxedTextColor.Text);
if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList)
{
var outputVisitor = new CSharpOutputVisitor(writer, formattingPolicy);
outputVisitor.WriteTypeParameters(node.GetChildrenByRole(Roles.TypeParameter), CodeBracesRangeFlags.AngleBrackets);
}
}
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 FullyQualifyAmbiguousTypeNamesVisitor(TransformContext context, UsingScope usingScope)
{
this.context = new Stack <CSharpTypeResolveContext>();
var currentContext = new CSharpTypeResolveContext(context.TypeSystem.MainAssembly, usingScope.Resolve(context.TypeSystem.Compilation));
this.context.Push(currentContext);
this.astBuilder = CreateAstBuilder(currentContext);
}
internal TransformContext(DecompilerTypeSystem typeSystem, ITypeResolveContext decompilationContext, TypeSystemAstBuilder typeSystemAstBuilder, DecompilerSettings settings, CancellationToken cancellationToken)
{
this.TypeSystem = typeSystem;
this.decompilationContext = decompilationContext;
this.TypeSystemAstBuilder = typeSystemAstBuilder;
this.Settings = settings;
this.CancellationToken = cancellationToken;
}
public AlCompletionDataFactory(AlCompletionContext completionContext, AlResolver contextAtCaret)
{
Debug.Assert(completionContext != null);
Debug.Assert(contextAtCaret != null);
this.completionContext = completionContext;
this.contextAtCaret = contextAtCaret;
this.builder = new TypeSystemAstBuilder(contextAtCaret);
}
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));
}
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));
}
TypeSystemAstBuilder CreateAstBuilder()
{
TypeSystemAstBuilder astBuilder = new TypeSystemAstBuilder();
astBuilder.ShowModifiers = (ConversionFlags & ConversionFlags.ShowModifiers) == ConversionFlags.ShowModifiers;
astBuilder.ShowAccessibility = (ConversionFlags & ConversionFlags.ShowAccessibility) == ConversionFlags.ShowAccessibility;
astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedTypeNames) != ConversionFlags.UseFullyQualifiedTypeNames;
return(astBuilder);
}
internal TransformContext(IDecompilerTypeSystem typeSystem, DecompileRun decompileRun, ITypeResolveContext decompilationContext, TypeSystemAstBuilder typeSystemAstBuilder)
{
this.TypeSystem = typeSystem;
this.DecompileRun = decompileRun;
this.decompilationContext = decompilationContext;
this.TypeSystemAstBuilder = typeSystemAstBuilder;
this.CancellationToken = decompileRun.CancellationToken;
this.Settings = decompileRun.Settings;
}
static void GenerateBodyFromContext(TypeSystemAstBuilder builder, DebuggerCompletionContext context, MethodDeclaration methodDeclaration)
{
methodDeclaration.Body = new BlockStatement();
foreach (var v in context.Variables)
{
methodDeclaration.Body.Statements.Add(new VariableDeclarationStatement(builder.ConvertType(v.Type), v.Name));
}
methodDeclaration.Body.Statements.Add(new ExpressionStatement(new IdentifierExpression("$__Caret_Point__$")));
}
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 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());
}
public string ConvertVariable(IVariable v)
{
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
AstNode astNode = astBuilder.ConvertVariable(v);
CSharpFormattingOptions formatting = new CSharpFormattingOptions();
StringWriter writer = new StringWriter();
astNode.AcceptVisitor(new CSharpOutputVisitor(writer, formatting), null);
return(writer.ToString().TrimEnd(';', '\r', '\n'));
}
public static string GetOverrideTargetName
(IMember m, CSharpTypeResolveContext resolveContext)
{
var builder = new TypeSystemAstBuilder
(new CSharpResolver(resolveContext));
return(builder.ConvertEntity(m).ToString()
// Builder automatically adds a trailing newline
.TrimEnd(Environment.NewLine.ToCharArray()));
}
internal static string GenerateMemberCode(MDRefactoringContext ctx, TypeSystemAstBuilder builder, IMember member)
{
var method = builder.ConvertEntity(member) as MethodDeclaration;
if (method != null)
{
method.Body = new BlockStatement {
new ThrowStatement(new ObjectCreateExpression(ctx.CreateShortType("System", "NotImplementedException")))
};
method.Modifiers &= ~Modifiers.Virtual;
method.Modifiers &= ~Modifiers.Abstract;
method.Attributes.Add(new AttributeSection {
Attributes =
{
GenerateExportAttribute(ctx, member)
}
});
return(method.ToString(ctx.FormattingOptions));
}
var property = builder.ConvertEntity(member) as PropertyDeclaration;
if (property == null)
{
return(null);
}
var p = (IProperty)member;
property.Modifiers &= ~Modifiers.Virtual;
property.Modifiers &= ~Modifiers.Abstract;
if (p.CanGet)
{
property.Getter.Body = new BlockStatement {
new ThrowStatement(new ObjectCreateExpression(ctx.CreateShortType("System", "NotImplementedException")))
};
property.Getter.Attributes.Add(new AttributeSection {
Attributes =
{
GenerateExportAttribute(ctx, p.Getter)
}
});
}
if (p.CanSet)
{
property.Setter.Body = new BlockStatement {
new ThrowStatement(new ObjectCreateExpression(ctx.CreateShortType("System", "NotImplementedException")))
};
property.Setter.Attributes.Add(new AttributeSection {
Attributes =
{
GenerateExportAttribute(ctx, p.Setter)
}
});
}
return(property.ToString(ctx.FormattingOptions));
}
static BlockStatement GenerateBodyFromContext(TypeSystemAstBuilder builder, IVariable[] variables)
{
var body = new BlockStatement();
foreach (var v in 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));
}
TypeSystemAstBuilder CreateAstBuilder()
{
TypeSystemAstBuilder astBuilder = new TypeSystemAstBuilder();
astBuilder.AddTypeReferenceAnnotations = true;
astBuilder.ShowTypeParametersForUnboundTypes = true;
astBuilder.ShowModifiers = (ConversionFlags & ConversionFlags.ShowModifiers) == ConversionFlags.ShowModifiers;
astBuilder.ShowAccessibility = (ConversionFlags & ConversionFlags.ShowAccessibility) == ConversionFlags.ShowAccessibility;
astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedTypeNames) != ConversionFlags.UseFullyQualifiedTypeNames;
astBuilder.ShowParameterNames = (ConversionFlags & ConversionFlags.ShowParameterNames) == ConversionFlags.ShowParameterNames;
return(astBuilder);
}
public override void VisitTypeDeclaration(TypeDeclaration typeDeclaration)
{
var currentContext = context.Peek().WithCurrentTypeDefinition(typeDeclaration.GetSymbol() as ITypeDefinition);
context.Push(currentContext);
try {
astBuilder = CreateAstBuilder(currentContext);
base.VisitTypeDeclaration(typeDeclaration);
} finally {
context.Pop();
}
}
public string ConvertType(IType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
TypeSystemAstBuilder astBuilder = CreateAstBuilder();
AstType astType = astBuilder.ConvertType(type);
return(astType.GetText());
}
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 member = file.GetMember(context.Location);
if (member == null)
{
return("");
}
var builder = new TypeSystemAstBuilder();
EntityDeclaration decl = builder.ConvertEntity(member.Resolve(new SimpleTypeResolveContext(compilation.MainAssembly)));
decl.Name = "__DebuggerStub_" + decl.Name;
decl.Modifiers &= (Modifiers.Static);
switch (member.SymbolKind)
{
case SymbolKind.Property:
break;
case SymbolKind.Indexer:
break;
case SymbolKind.Event:
break;
case SymbolKind.Method:
GenerateBodyFromContext(builder, context, (MethodDeclaration)decl);
break;
case SymbolKind.Operator:
break;
case SymbolKind.Constructor:
break;
case SymbolKind.Destructor:
break;
case SymbolKind.Accessor:
break;
default:
throw new ArgumentOutOfRangeException();
}
return(WrapInType(member.DeclaringTypeDefinition, decl.ToString()));
}
void WriteTypeDeclarationName(ITypeDefinition typeDef, TokenWriter writer, CSharpFormattingOptions formattingPolicy)
{
var astBuilder = new TypeSystemAstBuilder();
EntityDeclaration node = astBuilder.ConvertEntity(typeDef);
if (typeDef.DeclaringTypeDefinition != null)
{
WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, writer, formattingPolicy);
writer.WriteToken(Roles.Dot, ".");
}
writer.WriteIdentifier(node.NameToken);
WriteTypeParameters(writer, node.GetChildrenByRole(Roles.TypeParameter));
}
