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 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; }
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(); }
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 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) { 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 text = ctx.TranslateString("Collection element type '{0}' is not implicitly convertible to '{1}'"); AddIssue(variableType, string.Format(text, elementType.GetText(), variableType.GetText())); }
public override void Complete(CompletionContext context) { if (declarationBegin > context.StartOffset) { base.Complete(context); return; } TypeSystemAstBuilder b = new TypeSystemAstBuilder(contextAtCaret); b.ShowTypeParameterConstraints = false; b.GenerateBody = true; var entityDeclaration = b.ConvertEntity(this.Entity); entityDeclaration.Modifiers &= ~(Modifiers.Virtual | Modifiers.Abstract); entityDeclaration.Modifiers |= Modifiers.Override; if (!this.Entity.IsAbstract) { // modify body to call the base method if (this.Entity.SymbolKind == SymbolKind.Method) { var baseCall = new BaseReferenceExpression().Invoke(this.Entity.Name, ParametersToExpressions(this.Entity)); var body = entityDeclaration.GetChildByRole(Roles.Body); body.Statements.Clear(); if (((IMethod)this.Entity).ReturnType.IsKnownType(KnownTypeCode.Void)) body.Statements.Add(new ExpressionStatement(baseCall)); else body.Statements.Add(new ReturnStatement(baseCall)); } else if (this.Entity.SymbolKind == SymbolKind.Indexer || this.Entity.SymbolKind == SymbolKind.Property) { Expression baseCall; if (this.Entity.SymbolKind == SymbolKind.Indexer) baseCall = new BaseReferenceExpression().Indexer(ParametersToExpressions(this.Entity)); else baseCall = new BaseReferenceExpression().Member(this.Entity.Name); var getterBody = entityDeclaration.GetChildByRole(PropertyDeclaration.GetterRole).Body; if (!getterBody.IsNull) { getterBody.Statements.Clear(); getterBody.Add(new ReturnStatement(baseCall.Clone())); } var setterBody = entityDeclaration.GetChildByRole(PropertyDeclaration.SetterRole).Body; if (!setterBody.IsNull) { setterBody.Statements.Clear(); setterBody.Add(new AssignmentExpression(baseCall.Clone(), new IdentifierExpression("value"))); } } } var document = context.Editor.Document; StringWriter w = new StringWriter(); var formattingOptions = FormattingOptionsFactory.CreateSharpDevelop(); var segmentDict = SegmentTrackingOutputFormatter.WriteNode(w, entityDeclaration, formattingOptions, context.Editor.Options); using (document.OpenUndoGroup()) { string newText = w.ToString().TrimEnd(); document.Replace(declarationBegin, context.EndOffset - declarationBegin, newText); var throwStatement = entityDeclaration.Descendants.FirstOrDefault(n => n is ThrowStatement); if (throwStatement != null) { var segment = segmentDict[throwStatement]; context.Editor.Select(declarationBegin + segment.Offset, segment.Length); } CSharpFormatterHelper.Format(context.Editor, declarationBegin, newText.Length, formattingOptions); } }
private 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 void Complete(CompletionContext context) { if (declarationBegin > context.StartOffset) { base.Complete(context); return; } TypeSystemAstBuilder b = new TypeSystemAstBuilder(contextAtCaret); b.GenerateBody = true; var entityDeclaration = b.ConvertEntity(this.Entity); entityDeclaration.Modifiers &= ~Modifiers.VisibilityMask; // remove visiblity entityDeclaration.Modifiers |= Modifiers.Partial; var document = context.Editor.Document; StringWriter w = new StringWriter(); var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(contextAtCaret.Compilation.GetProject()); var segmentDict = SegmentTrackingOutputFormatter.WriteNode( w, entityDeclaration, formattingOptions.OptionsContainer.GetEffectiveOptions(), context.Editor.Options); using (document.OpenUndoGroup()) { string newText = w.ToString().TrimEnd(); document.Replace(declarationBegin, context.EndOffset - declarationBegin, newText); var throwStatement = entityDeclaration.Descendants.FirstOrDefault(n => n is ThrowStatement); if (throwStatement != null) { var segment = segmentDict[throwStatement]; context.Editor.Select(declarationBegin + segment.Offset, segment.Length); } CSharpFormatterHelper.Format(context.Editor, declarationBegin, newText.Length, formattingOptions.OptionsContainer); } }
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) 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}'"); AddIssue(variableType, string.Format(issueText, elementType.GetText(), variableType.GetText()), new CodeAction(string.Format(fixText, elementType.GetText()), script => script.Replace(variableType, elementType))); }
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 CSharpCompletionDataFactory(CSharpCompletionContext completionContext, CSharpResolver contextAtCaret) { Debug.Assert(completionContext != null); Debug.Assert(contextAtCaret != null); this.completionContext = completionContext; this.contextAtCaret = contextAtCaret; this.builder = new TypeSystemAstBuilder(contextAtCaret); }
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()); }
public SignatureMarkupCreator (CSharpResolver resolver, CSharpFormattingOptions formattingOptions) { this.colorStyle = SyntaxModeService.GetColorStyle (MonoDevelop.Ide.IdeApp.Preferences.ColorScheme); this.resolver = resolver; this.astBuilder = new TypeSystemAstBuilder (resolver) { ConvertUnboundTypeArguments = true, UseAliases = false }; this.formattingOptions = formattingOptions; }
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 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; } }
IEnumerable <CodeAction> GetActions(BaseRefactoringContext context, Expression targetExpression, IMember member) { var csResolver = context.Resolver.GetResolverStateBefore(targetExpression); var builder = new TypeSystemAstBuilder(csResolver); var newType = builder.ConvertType(member.DeclaringType); string description = string.Format("{0} '{1}'", context.TranslateString("Use base class"), newType.GetText()); yield return(new CodeAction(description, script => { script.Replace(targetExpression, newType); })); }
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.NameToken)); } }
public override void InsertEventHandler(ITypeDefinition target, string name, IEvent eventDefinition, bool jumpTo) { IUnresolvedTypeDefinition match = null; foreach (var part in target.Parts) { if (match == null || EntityModelContextUtils.IsBetterPart(part, match, ".cs")) match = part; } if (match == null) return; var view = SD.FileService.OpenFile(new FileName(match.Region.FileName), jumpTo); var editor = view.GetRequiredService<ITextEditor>(); var last = match.Members.LastOrDefault() ?? (IUnresolvedEntity)match; editor.Caret.Location = last.BodyRegion.End; var context = SDRefactoringContext.Create(editor, CancellationToken.None); var node = context.RootNode.GetNodeAt<EntityDeclaration>(last.Region.Begin); var resolver = context.GetResolverStateAfter(node); var builder = new TypeSystemAstBuilder(resolver); var delegateDecl = builder.ConvertEntity(eventDefinition.ReturnType.GetDefinition()) as DelegateDeclaration; if (delegateDecl == null) return; var throwStmt = new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException"))); var decl = new MethodDeclaration() { ReturnType = delegateDecl.ReturnType.Clone(), Name = name, Body = new BlockStatement() { throwStmt } }; var param = delegateDecl.Parameters.Select(p => p.Clone()).OfType<ParameterDeclaration>().ToArray(); decl.Parameters.AddRange(param); using (Script script = context.StartScript()) { // FIXME : will not work properly if there are no members. if (last == match) { throw new NotImplementedException(); // TODO InsertWithCursor not implemented! //script.InsertWithCursor("Insert event handler", Script.InsertPosition.End, decl).RunSynchronously(); } else { // TODO does not jump correctly... script.InsertAfter(node, decl); editor.JumpTo(throwStmt.StartLocation.Line, throwStmt.StartLocation.Column); } } }
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 string ConvertSymbol(ISymbol symbol) { var stringWriter = new StringWriter(); var astBuilder = new TypeSystemAstBuilder(); astBuilder.AlwaysUseShortTypeNames = true; AstNode node = astBuilder.ConvertSymbol(symbol); var writer = new TextWriterTokenWriter (stringWriter); var rt = node.GetChildByRole (Roles.Type); if (!rt.IsNull) { rt.AcceptVisitor (new CSharpOutputVisitor (stringWriter, FormattingOptionsFactory.CreateMono())); } IProperty property = symbol as IProperty; if (property != null) { writer.Space (); writer.WriteToken (Roles.LBrace, "{"); writer.Space (); if (property.CanGet) { writer.WriteKeyword (PropertyDeclaration.GetKeywordRole, "get"); writer.WriteToken (Roles.Semicolon, ";"); writer.Space (); } if (property.CanSet) { writer.WriteKeyword (PropertyDeclaration.SetKeywordRole, "set"); writer.WriteToken (Roles.Semicolon, ";"); writer.Space (); } writer.WriteToken (Roles.RBrace, "}"); } return stringWriter.ToString(); }
static string GeneratePartialClassContextStub(FileName fileName, TextLocation currentLocation, StackFrame context) { var compilation = SD.ParserService.GetCompilationForFile(fileName); var file = SD.ParserService.GetExistingUnresolvedFile(fileName); if (compilation == null || file == null) return ""; var member = file.GetMember(currentLocation); 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()); }
/// <summary> /// Takes an editing context. Inserts an override /// declaration of the chosen member in the context. Returns /// the new context. /// </summary> /// <remarks> /// The text editor cursor stays in the same line and column /// it originally was. /// </remarks> public RunOverrideTargetResponse RunOverrideTarget (RunOverrideTargetRequest request) { var overrideContext = new OverrideContext(request, _parser); var refactoringContext = OmniSharpRefactoringContext.GetContext (overrideContext.BufferParser, request); var memberToOverride = overrideContext.GetOverridableMembers() .First(ot => { var memberSignature = GetOverrideTargetsResponse.GetOverrideTargetName (ot, overrideContext.CompletionContext.ResolveContext); return memberSignature == request.OverrideTargetName;}); var builder = new TypeSystemAstBuilder (new CSharpResolver (overrideContext.CompletionContext.ResolveContext)) // Will generate a "throw new // NotImplementedException();" statement in the // bodies {GenerateBody = true}; var newEditorContents = runOverrideTargetWorker ( request , refactoringContext , overrideContext.CompletionContext.ParsedContent , script: new OmniSharpScript(refactoringContext, _config) , memberDeclaration: builder.ConvertEntity(memberToOverride)); return new RunOverrideTargetResponse ( fileName : request.FileName , buffer : newEditorContents.Text , line : request.Line , column : request.Column); }
TypeSystemAstBuilder CreateAstBuilder() { TypeSystemAstBuilder astBuilder = new TypeSystemAstBuilder(); return astBuilder; }
public override void Complete(CompletionContext context) { if (declarationBegin > context.StartOffset) { base.Complete(context); return; } TypeSystemAstBuilder b = new TypeSystemAstBuilder(contextAtCaret); b.ShowTypeParameterConstraints = false; b.GenerateBody = true; var entityDeclaration = b.ConvertEntity(this.Entity); entityDeclaration.Modifiers &= ~(Modifiers.Virtual | Modifiers.Abstract); entityDeclaration.Modifiers |= Modifiers.Override; var body = entityDeclaration.GetChildByRole(Roles.Body); Statement baseCallStatement = body.Children.OfType<Statement>().FirstOrDefault(); if (!this.Entity.IsAbstract) { // modify body to call the base method if (this.Entity.SymbolKind == SymbolKind.Method) { var baseCall = new BaseReferenceExpression().Invoke(this.Entity.Name, new Expression[] { }); if (((IMethod)this.Entity).ReturnType.IsKnownType(KnownTypeCode.Void)) baseCallStatement = new ExpressionStatement(baseCall); else baseCallStatement = new ReturnStatement(baseCall); // Clear body of inserted method entityDeclaration.GetChildByRole(Roles.Body).Statements.Clear(); } } var document = context.Editor.Document; StringWriter w = new StringWriter(); var formattingOptions = FormattingOptionsFactory.CreateSharpDevelop(); var segmentDict = SegmentTrackingOutputFormatter.WriteNode(w, entityDeclaration, formattingOptions, context.Editor.Options); using (document.OpenUndoGroup()) { InsertionContext insertionContext = new InsertionContext(context.Editor.GetService(typeof(TextArea)) as TextArea, declarationBegin); insertionContext.InsertionPosition = context.Editor.Caret.Offset; string newText = w.ToString().TrimEnd(); document.Replace(declarationBegin, context.EndOffset - declarationBegin, newText); var throwStatement = entityDeclaration.Descendants.FirstOrDefault(n => n is ThrowStatement); if (throwStatement != null) { var segment = segmentDict[throwStatement]; context.Editor.Select(declarationBegin + segment.Offset, segment.Length); } CSharpFormatterHelper.Format(context.Editor, declarationBegin, newText.Length, formattingOptions); var refactoringContext = SDRefactoringContext.Create(context.Editor, CancellationToken.None); var typeResolveContext = refactoringContext.GetTypeResolveContext(); if (typeResolveContext == null) { return; } var resolvedCurrent = typeResolveContext.CurrentTypeDefinition; var entities = FindFieldsAndProperties(resolvedCurrent).ToList(); if (entities.Any()) { IEditorUIService uiService = context.Editor.GetService(typeof(IEditorUIService)) as IEditorUIService; ITextAnchor endAnchor = context.Editor.Document.CreateAnchor(context.Editor.Caret.Offset); endAnchor.MovementType = AnchorMovementType.AfterInsertion; ITextAnchor startAnchor = context.Editor.Document.CreateAnchor(context.Editor.Caret.Offset); startAnchor.MovementType = AnchorMovementType.BeforeInsertion; ITextAnchor insertionPos = context.Editor.Document.CreateAnchor(endAnchor.Offset); insertionPos.MovementType = AnchorMovementType.BeforeInsertion; AbstractInlineRefactorDialog dialog = new OverrideToStringMethodDialog(insertionContext, context.Editor, insertionPos, entities, baseCallStatement); dialog.Element = uiService.CreateInlineUIElement(insertionPos, dialog); insertionContext.RegisterActiveElement(new InlineRefactorSnippetElement(cxt => null, ""), dialog); } else { if (baseCallStatement != null) { // Add default base call MethodDeclaration insertedOverrideMethod = refactoringContext.GetNode().PrevSibling as MethodDeclaration; if (insertedOverrideMethod == null) { // We are not inside of a method declaration return; } using (Script script = refactoringContext.StartScript()) { script.AddTo(insertedOverrideMethod.Body, baseCallStatement); } } } insertionContext.RaiseInsertionCompleted(EventArgs.Empty); } }
string AddDelegateHandlers(CompletionDataWrapper completionList, IType delegateType, bool addSemicolon = true, bool addDefault = true, string optDelegateName = null) { IMethod delegateMethod = delegateType.GetDelegateInvokeMethod(); PossibleDelegates.Add(delegateMethod); var thisLineIndent = GetLineIndent(location.Line); string delegateEndString = EolMarker + thisLineIndent + "}" + (addSemicolon ? ";" : ""); //bool containsDelegateData = completionList.Result.Any(d => d.DisplayText.StartsWith("delegate(")); if (addDefault && !completionList.AnonymousDelegateAdded) { completionList.AnonymousDelegateAdded = true; var oldDelegate = completionList.Result.FirstOrDefault(cd => cd.DisplayText == "delegate"); if (oldDelegate != null) completionList.Result.Remove(oldDelegate); completionList.AddCustom( "delegate", "Creates anonymous delegate.", "delegate {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); if (LanguageVersion.Major >= 5) { completionList.AddCustom( "async delegate", "Creates anonymous async delegate.", "async delegate {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); } } var sb = new StringBuilder("("); var sbWithoutTypes = new StringBuilder("("); var state = GetState(); var builder = new TypeSystemAstBuilder(state); for (int k = 0; k < delegateMethod.Parameters.Count; k++) { if (k > 0) { sb.Append(", "); sbWithoutTypes.Append(", "); } var convertedParameter = builder.ConvertParameter(delegateMethod.Parameters [k]); if (convertedParameter.ParameterModifier == ParameterModifier.Params) convertedParameter.ParameterModifier = ParameterModifier.None; sb.Append(convertedParameter.ToString(FormattingPolicy)); sbWithoutTypes.Append(delegateMethod.Parameters [k].Name); } sb.Append(")"); sbWithoutTypes.Append(")"); var signature = sb.ToString(); if (!completionList.HasAnonymousDelegateAdded(signature)) { completionList.AddAnonymousDelegateAdded(signature); completionList.AddCustom( "delegate" + signature, "Creates anonymous delegate.", "delegate" + signature + " {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); if (LanguageVersion.Major >= 5) { completionList.AddCustom( "async delegate" + signature, "Creates anonymous async delegate.", "async delegate" + signature + " {" + EolMarker + thisLineIndent + IndentString + "|" + delegateEndString ); } if (!completionList.Result.Any(data => data.DisplayText == sb.ToString())) { completionList.AddCustom( signature, "Creates typed lambda expression.", signature + " => |" + (addSemicolon ? ";" : "") ); if (LanguageVersion.Major >= 5) { completionList.AddCustom( "async " + signature, "Creates typed async lambda expression.", "async " + signature + " => |" + (addSemicolon ? ";" : "") ); } if (!delegateMethod.Parameters.Any(p => p.IsOut || p.IsRef) && !completionList.Result.Any(data => data.DisplayText == sbWithoutTypes.ToString())) { completionList.AddCustom( sbWithoutTypes.ToString(), "Creates lambda expression.", sbWithoutTypes + " => |" + (addSemicolon ? ";" : "") ); if (LanguageVersion.Major >= 5) { completionList.AddCustom( "async " + sbWithoutTypes, "Creates async lambda expression.", "async " + sbWithoutTypes + " => |" + (addSemicolon ? ";" : "") ); } } } } string varName = "Handle" + delegateType.Name + optDelegateName; completionList.Add(factory.CreateEventCreationCompletionData(varName, delegateType, null, signature, currentMember, currentType)); /* TODO:Make factory method out of it. // It's needed to temporarly disable inserting auto matching bracket because the anonymous delegates are selectable with '(' // otherwise we would end up with () => ) if (!containsDelegateData) { var savedValue = MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket; MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket = false; completionList.Result.CompletionListClosed += delegate { MonoDevelop.SourceEditor.DefaultSourceEditorOptions.Instance.AutoInsertMatchingBracket = savedValue; }; }*/ return sb.ToString(); }
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 otherRefes = IdeApp.Workspace != null ? curProject.GetReferencedItems (IdeApp.Workspace.ActiveConfiguration).ToList () : (IEnumerable<SolutionItem>) new SolutionItem[0]; if (otherRefes.Contains (project)) 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; FrameworkLookup frameworkLookup; if (!TypeSystemService.TryGetFrameworkLookup (netProject, out frameworkLookup)) frameworkLookup = null; if (frameworkLookup != null && resolveResult is UnknownMemberResolveResult) { var umResult = (UnknownMemberResolveResult)resolveResult; try { foreach (var r in frameworkLookup.GetExtensionMethodLookups (umResult)) { var systemAssembly = netProject.AssemblyContext.GetAssemblyFromFullName (r.FullName, r.Package, netProject.TargetFramework); if (systemAssembly == null) continue; if (CanBeReferenced (doc.Project, systemAssembly)) compilations.Add (Tuple.Create (TypeSystemService.GetCompilation (systemAssembly, doc.Compilation), new MonoDevelop.Projects.ProjectReference (systemAssembly))); } } catch (Exception e) { if (!TypeSystemService.RecreateFrameworkLookup (netProject)) LoggingService.LogError (string.Format ("Error while looking up extension method {0}", umResult.MemberName), e); } } 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.Name == uiResult.Identifier) && 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)) { if (!lookup.IsAccessible (typeDefinition, false)) continue; foreach (var method in typeDefinition.Methods.Where (m => m.IsExtensionMethod && (m.Name == possibleAttributeName || m.Name == umResult.MemberName))) { if (!lookup.IsAccessible (method, false)) continue; 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 || identifier.Name == uiResult.Identifier) && typeDefinition.TypeParameterCount == tc && lookup.IsAccessible (typeDefinition, false)) yield return new PossibleNamespace (typeDefinition.Namespace, true, requiredReference); } } } } } // Try to search framework types if (!foundIdentifier && frameworkLookup != null && resolveResult is UnknownIdentifierResolveResult && node is AstType) { var uiResult = resolveResult as UnknownIdentifierResolveResult; if (uiResult != null) { var lookups = new List<Tuple<FrameworkLookup.AssemblyLookup, SystemAssembly>> (); try { foreach (var r in frameworkLookup.GetLookups (uiResult, tc, isInsideAttributeType)) { var systemAssembly = netProject.AssemblyContext.GetAssemblyFromFullName (r.FullName, r.Package, netProject.TargetFramework); if (systemAssembly == null) continue; if (CanBeReferenced (doc.Project, systemAssembly)) lookups.Add (Tuple.Create (r, systemAssembly)); } } catch (Exception e) { if (!TypeSystemService.RecreateFrameworkLookup (netProject)) LoggingService.LogError (string.Format ("Error while looking up identifier {0}", uiResult.Identifier), e); } foreach(var kv in lookups) yield return new PossibleNamespace (kv.Item1.Namespace, true, new MonoDevelop.Projects.ProjectReference (kv.Item2)); } } if (!foundIdentifier && frameworkLookup != null && resolveResult is UnknownMemberResolveResult) { var uiResult = resolveResult as UnknownMemberResolveResult; if (uiResult != null) { var lookups = new List<Tuple<FrameworkLookup.AssemblyLookup, SystemAssembly>> (); try { foreach (var r in frameworkLookup.GetLookups (uiResult, node.ToString (), tc, isInsideAttributeType)) { var systemAssembly = netProject.AssemblyContext.GetAssemblyFromFullName (r.FullName, r.Package, netProject.TargetFramework); if (systemAssembly == null) continue; if (CanBeReferenced (doc.Project, systemAssembly)) lookups.Add (Tuple.Create (r, systemAssembly)); } } catch (Exception e) { if (!TypeSystemService.RecreateFrameworkLookup (netProject)) LoggingService.LogError (string.Format ("Error while looking up member resolve result {0}", node), e); } foreach(var kv in lookups) yield return new PossibleNamespace (kv.Item1.Namespace, true, new MonoDevelop.Projects.ProjectReference (kv.Item2)); } } }
string GetShortType(IType type, CSharpResolver state) { var builder = new TypeSystemAstBuilder(state); var dt = state.CurrentTypeDefinition; var declaring = type.DeclaringType != null ? type.DeclaringType.GetDefinition() : null; if (declaring != null) { while (dt != null) { if (dt.Equals(declaring)) { builder.AlwaysUseShortTypeNames = true; break; } dt = dt.DeclaringTypeDefinition; } } var shortType = builder.ConvertType(type); return shortType.GetText(FormattingPolicy); }
static void GenerateBodyFromContext(TypeSystemAstBuilder builder, StackFrame context, MethodDeclaration methodDeclaration) { methodDeclaration.Body = new BlockStatement(); foreach (var v in context.GetLocalVariables()) methodDeclaration.Body.Statements.Add(new VariableDeclarationStatement(builder.ConvertType(v.Type), v.Name)); methodDeclaration.Body.Statements.Add(new ExpressionStatement(new IdentifierExpression("$__Caret_Point__$"))); }
public static ICSharpCode.NRefactory.CSharp.AstType ConvertToAstType(this IType type) { var builder = new TypeSystemAstBuilder(MinimalResolveContext.Instance); return(builder.ConvertType(type)); }
void AddAttribute(DomRegion region, IAttribute attribute, string target = "") { var view = SD.FileService.OpenFile(new FileName(region.FileName), false); var editor = view.GetRequiredService<ITextEditor>(); var context = SDRefactoringContext.Create(editor.FileName, editor.Document, region.Begin, CancellationToken.None); var node = context.RootNode.GetNodeAt<EntityDeclaration>(region.Begin); var resolver = context.GetResolverStateBefore(node); var builder = new TypeSystemAstBuilder(resolver); using (Script script = context.StartScript()) { var attr = new AttributeSection(); attr.AttributeTarget = target; attr.Attributes.Add(builder.ConvertAttribute(attribute)); script.InsertBefore(node, attr); } }
static TypeSystemAstBuilder CreateBuilder (MonoDevelop.Ide.Gui.Document doc, int offset, ICompilation compilation) { var ctx = doc.ParsedDocument.ParsedFile.GetTypeResolveContext (doc.Compilation, doc.Editor.Caret.Location) as CSharpTypeResolveContext; var state = new CSharpResolver (ctx); var builder = new TypeSystemAstBuilder (state); builder.AddAnnotations = true; 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; } } return builder; }
public static ICSharpCode.NRefactory.CSharp.AstType ConvertToAstType(this IType type) { var builder = new TypeSystemAstBuilder(); return(builder.ConvertType(type)); }
TypeSystemAstBuilder CreateAstBuilder() { TypeSystemAstBuilder astBuilder = new TypeSystemAstBuilder(); astBuilder.AddAnnotations = 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; }
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)); }
/// <summary> Get the value of the node and update the UI text fields. </summary> /// <remarks> This should be only called once so the Value is not cached. </remarks> void GetValueAndUpdateUI() { try { Stopwatch watch = new Stopwatch(); watch.Start(); // Do not keep permanent reference Value val = this.getValue(); if (val == null) { Value = string.Empty; Type = string.Empty; GetChildren = null; VisualizerCommands = null; return; } // Note that the child collections are lazy-evaluated if (val.IsNull) { this.GetChildren = null; } else if (val.Type.IsPrimitiveType() || val.Type.IsKnownType(KnownTypeCode.String)) { // Must be before IsClass this.GetChildren = null; } else if (val.Type.Kind == TypeKind.Array) { // Must be before IsClass var dimBase = val.ArrayBaseIndicies; // Eval now var dimSize = val.ArrayDimensions; // Eval now if (val.ArrayLength > 0) { this.GetChildren = () => GetArrayChildren(dimBase, dimSize); } } else if (val.Type.Kind == TypeKind.Class || val.Type.Kind == TypeKind.Struct) { if (val.Type.IsKnownType(typeof(List<>))) { if ((int)val.GetFieldValue("_size").PrimitiveValue > 0) this.GetChildren = () => GetIListChildren(this.GetValue); } else { this.GetChildren = () => GetObjectChildren(val.Type); } } else if (val.Type.Kind == TypeKind.Pointer) { if (val.Dereference() != null) { this.GetChildren = () => new[] { new ValueNode(ClassBrowserIconService.LocalVariable, "*" + this.Name, () => GetValue().Dereference()) }; } } // Do last since it may expire the object if (val.IsNull) { fullValue = "null"; } else if (val.Type.IsInteger()) { var i = val.PrimitiveValue; if (DebuggingOptions.Instance.ShowIntegersAs == ShowIntegersAs.Decimal) { fullValue = i.ToString(); } else { string hex = string.Format("0x{0:X4}", i); if (hex.Length > 6 ) hex = string.Format("0x{0:X8}", i); if (hex.Length > 10) hex = string.Format("0x{0:X16}", i); if (DebuggingOptions.Instance.ShowIntegersAs == ShowIntegersAs.Hexadecimal) { fullValue = hex; } else { fullValue = string.Format("{0} ({1})", i, hex); } } } else if (val.Type.Kind == TypeKind.Pointer) { fullValue = String.Format("0x{0:X}", val.PointerAddress); } else if (val.Type.IsKnownType(KnownTypeCode.String)) { fullValue = '"' + val.InvokeToString(WindowsDebugger.EvalThread).Replace("\n", "\\n").Replace("\t", "\\t").Replace("\r", "\\r").Replace("\0", "\\0").Replace("\b", "\\b").Replace("\a", "\\a").Replace("\f", "\\f").Replace("\v", "\\v").Replace("\"", "\\\"") + '"'; } else if (val.Type.IsKnownType(KnownTypeCode.Char)) { fullValue = "'" + val.InvokeToString(WindowsDebugger.EvalThread).Replace("\n", "\\n").Replace("\t", "\\t").Replace("\r", "\\r").Replace("\0", "\\0").Replace("\b", "\\b").Replace("\a", "\\a").Replace("\f", "\\f").Replace("\v", "\\v").Replace("\"", "\\\"") + "'"; } else if ((val.Type.Kind == TypeKind.Class || val.Type.Kind == TypeKind.Struct)) { fullValue = val.FormatByDebuggerDisplayAttribute(WindowsDebugger.EvalThread); if (fullValue == null) fullValue = val.InvokeToString(WindowsDebugger.EvalThread); } else if (val.Type.Kind == TypeKind.Enum) { var primitiveValue = val.PrimitiveValue; var builder = new TypeSystemAstBuilder(); builder.AlwaysUseShortTypeNames = true; AstNode node = builder.ConvertConstantValue(val.Type, primitiveValue); fullValue = node + "=" + primitiveValue; } else { fullValue = val.AsString(); } this.error = null; this.Value = (fullValue.Length > 256) ? fullValue.Substring(0, 256) + "..." : fullValue; this.Type = val.Type.Name; if (!val.IsNull) { this.VisualizerCommands = VisualizerDescriptors.GetAllDescriptors() .Where(descriptor => descriptor.IsVisualizerAvailable(val.Type)) .Select(descriptor => descriptor.CreateVisualizerCommand(this.Name, this.GetValue)) .ToList(); } LoggingService.InfoFormatted("Evaluated node '{0}' in {1} ms", this.Name, watch.ElapsedMilliseconds); } catch (GetValueException e) { error = e; this.Value = e.Message; this.Type = string.Empty; this.GetChildren = null; this.VisualizerCommands = null; } finally { if (error == null) ContextMenuAddInTreeEntry = "/AddIns/Debugger/Tooltips/ContextMenu/ValueNode"; else ContextMenuAddInTreeEntry = "/AddIns/Debugger/Tooltips/ContextMenu/ErrorNode"; } }
public string GetTypeReferenceString (IType type, bool highlight = true) { if (type == null) throw new ArgumentNullException ("type"); if (type.Kind == TypeKind.Null) return "?"; if (type.Kind == TypeKind.Array) { var arrayType = (ArrayType)type; return GetTypeReferenceString (arrayType.ElementType, highlight) + "[" + new string (',', arrayType.Dimensions - 1) + "]"; } if (type.Kind == TypeKind.Pointer) return GetTypeReferenceString (((PointerType)type).ElementType, highlight) + "*"; AstType astType; try { astType = astBuilder.ConvertType (type); } catch (Exception e) { var compilation = GetCompilation (type); if (compilation == null) { Console.WriteLine ("type:"+type.GetType ()); Console.WriteLine ("got exception while conversion:" + e); return "?"; } astType = new TypeSystemAstBuilder (new CSharpResolver (compilation)).ConvertType (type); } if (astType is PrimitiveType) { return Highlight (astType.ToString (formattingOptions), colorStyle.KeywordTypes); } var text = AmbienceService.EscapeText (astType.ToString (formattingOptions)); return highlight ? HighlightSemantically (text, colorStyle.UserTypes) : text; }