diff --git a/src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.addin b/src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.addin
index cbb95cfdbc..00afab804e 100644
--- a/src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.addin
+++ b/src/AddIns/BackendBindings/CSharpBinding/Project/CSharpBinding.addin
@@ -11,12 +11,11 @@
-
+ class = "ICSharpCode.SharpDevelop.CSharpAmbience"/>
diff --git a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/Parser.cs b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/Parser.cs
index 1e7f78d0e4..6c67939438 100644
--- a/src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/Parser.cs
+++ b/src/AddIns/BackendBindings/CSharpBinding/Project/Src/Parser/Parser.cs
@@ -5,6 +5,7 @@ using System;
using System.IO;
using ICSharpCode.Core;
using ICSharpCode.Editor;
+using ICSharpCode.NRefactory.CSharp;
using ICSharpCode.NRefactory.TypeSystem;
using ICSharpCode.SharpDevelop;
using ICSharpCode.SharpDevelop.Parser;
@@ -66,7 +67,14 @@ namespace CSharpBinding.Parser
public ParseInformation Parse(IProjectContent projectContent, FileName fileName, ITextSource fileContent,
bool fullParseInformationRequested)
{
- throw new NotImplementedException();
+ CSharpParser parser = new CSharpParser();
+ parser.GenerateTypeSystemMode = true;
+ CompilationUnit cu = parser.Parse(fileContent.CreateReader());
+
+ TypeSystemConvertVisitor cv = new TypeSystemConvertVisitor(projectContent, fileName);
+ ParsedFile file = cv.Convert(cu);
+
+ return new ParseInformation(file, true);
}
/*void AddCommentTags(ICompilationUnit cu, System.Collections.Generic.List tagComments)
diff --git a/src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/CodeEditor.cs b/src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/CodeEditor.cs
index f4242fddc5..f1f8fcd9dd 100644
--- a/src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/CodeEditor.cs
+++ b/src/AddIns/DisplayBindings/AvalonEdit.AddIn/Src/CodeEditor.cs
@@ -569,7 +569,7 @@ namespace ICSharpCode.AvalonEdit.AddIn
quickClassBrowser = null;
}
}
- iconBarManager.UpdateClassMemberBookmarks(parseInfo.ParsedFile);
+ iconBarManager.UpdateClassMemberBookmarks(parseInfo != null ? parseInfo.ParsedFile : null);
primaryTextEditor.UpdateParseInformationForFolding(parseInfo);
if (secondaryTextEditor != null)
secondaryTextEditor.UpdateParseInformationForFolding(parseInfo);
diff --git a/src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit/Document/RopeTextSource.cs b/src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit/Document/RopeTextSource.cs
index 349e98d8f7..a222676ecf 100644
--- a/src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit/Document/RopeTextSource.cs
+++ b/src/Libraries/AvalonEdit/ICSharpCode.AvalonEdit/Document/RopeTextSource.cs
@@ -97,7 +97,7 @@ namespace ICSharpCode.AvalonEdit.Document
string ITextSource.GetText(ICSharpCode.Editor.ISegment segment)
{
- throw new NotImplementedException();
+ return rope.ToString(segment.Offset, segment.Length);
}
}
}
diff --git a/src/Libraries/NRefactory/ICSharpCode.NRefactory/CSharp/Refactoring/RefactoringContext.cs b/src/Libraries/NRefactory/ICSharpCode.NRefactory/CSharp/Refactoring/RefactoringContext.cs
index a73d973733..6d2aa2cf79 100644
--- a/src/Libraries/NRefactory/ICSharpCode.NRefactory/CSharp/Refactoring/RefactoringContext.cs
+++ b/src/Libraries/NRefactory/ICSharpCode.NRefactory/CSharp/Refactoring/RefactoringContext.cs
@@ -1,4 +1,4 @@
-//
+//
// RefactoringContext.cs
//
// Author:
@@ -25,9 +25,9 @@
// THE SOFTWARE.
using System;
using System.Linq;
-using ICSharpCode.NRefactory.TypeSystem;
-using System.Collections.Generic;
using ICSharpCode.NRefactory.CSharp.Resolver;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem.Implementation;
namespace ICSharpCode.NRefactory.CSharp.Refactoring
{
@@ -127,12 +127,12 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
}
}
- public static class ExtensionMethods
+ public static class RefactoringExtensions
{
#region ConvertTypes
public static ICSharpCode.NRefactory.CSharp.AstType ConvertToAstType (this IType type)
{
- var builder = new TypeSystemAstBuilder ();
+ var builder = new TypeSystemAstBuilder (MinimalResolveContext.Instance);
return builder.ConvertType (type);
}
#endregion
diff --git a/src/Libraries/NRefactory/ICSharpCode.NRefactory/CSharp/Refactoring/TypeSystemAstBuilder.cs b/src/Libraries/NRefactory/ICSharpCode.NRefactory/CSharp/Refactoring/TypeSystemAstBuilder.cs
index f9d9ff18e9..b67ab0cd9f 100644
--- a/src/Libraries/NRefactory/ICSharpCode.NRefactory/CSharp/Refactoring/TypeSystemAstBuilder.cs
+++ b/src/Libraries/NRefactory/ICSharpCode.NRefactory/CSharp/Refactoring/TypeSystemAstBuilder.cs
@@ -8,6 +8,7 @@ using System.Linq;
using ICSharpCode.NRefactory.CSharp.Resolver;
using ICSharpCode.NRefactory.TypeSystem;
using ICSharpCode.NRefactory.TypeSystem.Implementation;
+using ICSharpCode.NRefactory.Utils;
namespace ICSharpCode.NRefactory.CSharp.Refactoring
{
@@ -17,6 +18,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
public class TypeSystemAstBuilder
{
readonly CSharpResolver resolver;
+ readonly ITypeResolveContext context;
///
/// Creates a new TypeSystemAstBuilder.
@@ -24,11 +26,73 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
///
/// A resolver initialized for the position where the type will be inserted.
///
- public TypeSystemAstBuilder(CSharpResolver resolver = null)
+ public TypeSystemAstBuilder(CSharpResolver resolver)
{
+ if (resolver == null)
+ throw new ArgumentNullException("resolver");
this.resolver = resolver;
+ this.context = resolver.Context;
+ InitProperties();
}
+ public TypeSystemAstBuilder(ITypeResolveContext context)
+ {
+ if (context == null)
+ throw new ArgumentNullException("context");
+ this.context = context;
+ InitProperties();
+ }
+
+ #region Properties
+ void InitProperties()
+ {
+ this.ShowAccessibility = true;
+ this.ShowModifiers = true;
+ this.ShowBaseTypes = true;
+ this.ShowTypeParameters = true;
+ this.ShowTypeParameterConstraints = true;
+ this.ShowParameterNames = true;
+ this.ShowConstantValues = true;
+ }
+
+ ///
+ /// Controls the accessibility modifiers are shown.
+ ///
+ public bool ShowAccessibility { get; set; }
+
+ ///
+ /// Controls the non-accessibility modifiers are shown.
+ ///
+ public bool ShowModifiers { get; set; }
+
+ ///
+ /// Controls whether base type references are shown.
+ ///
+ public bool ShowBaseTypes { get; set; }
+
+ ///
+ /// Controls whether type parameter declarations are shown.
+ ///
+ public bool ShowTypeParameters { get; set; }
+
+ ///
+ /// Controls whether contraints on type parameter declarations are shown.
+ /// Has no effect if ShowTypeParameters is false.
+ ///
+ public bool ShowTypeParameterConstraints { get; set; }
+
+ ///
+ /// Controls whether the names of parameters are shown.
+ ///
+ public bool ShowParameterNames { get; set; }
+
+ ///
+ /// Controls whether to show default values of optional parameters, and the values of constant fields.
+ ///
+ public bool ShowConstantValues { get; set; }
+ #endregion
+
+ #region Convert Type
public AstType ConvertType(IType type)
{
if (type == null)
@@ -49,7 +113,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
if (pt.Name == "Nullable" && pt.Namespace == "System" && pt.TypeParameterCount == 1) {
return ConvertType(pt.TypeArguments[0]).MakeNullableType();
}
- return ConvertTypeDefinition(pt.GetDefinition(), pt.TypeArguments);
+ return ConvertTypeHelper(pt.GetDefinition(), pt.TypeArguments);
}
ITypeDefinition typeDef = type as ITypeDefinition;
if (typeDef != null) {
@@ -59,15 +123,15 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
for (int i = 0; i < typeArguments.Length; i++) {
typeArguments[i] = SharedTypes.UnboundTypeArgument;
}
- return ConvertTypeDefinition(typeDef, typeArguments);
+ return ConvertTypeHelper(typeDef, typeArguments);
} else {
- return ConvertTypeDefinition(typeDef, EmptyList.Instance);
+ return ConvertTypeHelper(typeDef, EmptyList.Instance);
}
}
return new SimpleType(type.Name);
}
- AstType ConvertTypeDefinition(ITypeDefinition typeDef, IList typeArguments)
+ AstType ConvertTypeHelper(ITypeDefinition typeDef, IList typeArguments)
{
Debug.Assert(typeArguments.Count >= typeDef.TypeParameterCount);
switch (ReflectionHelper.GetTypeCode(typeDef)) {
@@ -144,7 +208,7 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
MemberType result = new MemberType();
if (typeDef.DeclaringTypeDefinition != null) {
// Handle nested types
- result.Target = ConvertTypeDefinition(typeDef.DeclaringTypeDefinition, typeArguments);
+ result.Target = ConvertTypeHelper(typeDef.DeclaringTypeDefinition, typeArguments);
} else {
// Handle top-level types
if (string.IsNullOrEmpty(typeDef.Namespace)) {
@@ -238,5 +302,374 @@ namespace ICSharpCode.NRefactory.CSharp.Refactoring
NamespaceResolveResult nrr = resolver.ResolveSimpleName(firstNamespacePart, EmptyList.Instance) as NamespaceResolveResult;
return nrr != null && !nrr.IsError && nrr.NamespaceName == firstNamespacePart;
}
+ #endregion
+
+ #region Convert Constant Value
+ public Expression ConvertConstantValue(IConstantValue constantValue)
+ {
+ if (constantValue == null)
+ throw new ArgumentNullException("constantValue");
+ IType type = constantValue.GetValueType(context);
+ object val = constantValue.GetValue(context);
+ if (val == null) {
+ if (type.IsReferenceType(context) == true)
+ return new NullReferenceExpression();
+ else
+ return new DefaultValueExpression(ConvertType(type));
+ } else if (type.Kind == TypeKind.Enum) {
+ throw new NotImplementedException();
+ } else {
+ return new PrimitiveExpression(val);
+ }
+ }
+ #endregion
+
+ #region Convert Parameter
+ public ParameterDeclaration ConvertParameter(IParameter parameter)
+ {
+ if (parameter == null)
+ throw new ArgumentNullException("parameter");
+ ParameterDeclaration decl = new ParameterDeclaration();
+ if (parameter.IsRef) {
+ decl.ParameterModifier = ParameterModifier.Ref;
+ } else if (parameter.IsOut) {
+ decl.ParameterModifier = ParameterModifier.Out;
+ } else if (parameter.IsParams) {
+ decl.ParameterModifier = ParameterModifier.Params;
+ }
+ decl.Type = ConvertType(parameter.Type.Resolve(context));
+ if (this.ShowParameterNames) {
+ decl.Name = parameter.Name;
+ }
+ if (parameter.IsOptional && this.ShowConstantValues) {
+ decl.DefaultExpression = ConvertConstantValue(parameter.DefaultValue);
+ }
+ return decl;
+ }
+ #endregion
+
+ #region Convert Entity
+ public AstNode ConvertEntity(IEntity entity)
+ {
+ if (entity == null)
+ throw new ArgumentNullException("entity");
+ switch (entity.EntityType) {
+ case EntityType.TypeDefinition:
+ return ConvertTypeDefinition((ITypeDefinition)entity);
+ case EntityType.Field:
+ return ConvertField((IField)entity);
+ case EntityType.Property:
+ return ConvertProperty((IProperty)entity);
+ case EntityType.Indexer:
+ return ConvertIndexer((IProperty)entity);
+ case EntityType.Event:
+ return ConvertEvent((IEvent)entity);
+ case EntityType.Method:
+ return ConvertMethod((IMethod)entity);
+ case EntityType.Operator:
+ return ConvertOperator((IMethod)entity);
+ case EntityType.Constructor:
+ return ConvertConstructor((IMethod)entity);
+ case EntityType.Destructor:
+ return ConvertDestructor((IMethod)entity);
+ default:
+ throw new ArgumentException("Invalid value for EntityType: " + entity.EntityType);
+ }
+ }
+
+ AttributedNode ConvertTypeDefinition(ITypeDefinition typeDefinition)
+ {
+ Modifiers modifiers = ModifierFromAccessibility(typeDefinition.Accessibility);
+ if (this.ShowModifiers) {
+ if (typeDefinition.IsStatic) {
+ modifiers |= Modifiers.Static;
+ } else if (typeDefinition.IsAbstract) {
+ modifiers |= Modifiers.Abstract;
+ } else if (typeDefinition.IsSealed) {
+ modifiers |= Modifiers.Sealed;
+ }
+ if (typeDefinition.IsShadowing) {
+ modifiers |= Modifiers.New;
+ }
+ }
+
+ ClassType classType;
+ switch (typeDefinition.Kind) {
+ case TypeKind.Struct:
+ classType = ClassType.Struct;
+ break;
+ case TypeKind.Enum:
+ classType = ClassType.Enum;
+ break;
+ case TypeKind.Interface:
+ classType = ClassType.Interface;
+ break;
+ case TypeKind.Delegate:
+ IMethod invoke = typeDefinition.GetDelegateInvokeMethod();
+ if (invoke != null)
+ return ConvertDelegate(invoke, modifiers);
+ else
+ goto default;
+ default:
+ classType = ClassType.Class;
+ break;
+ }
+
+ TypeDeclaration decl = new TypeDeclaration();
+ decl.Modifiers = modifiers;
+ decl.ClassType = classType;
+ decl.Name = typeDefinition.Name;
+
+ if (this.ShowTypeParameters) {
+ foreach (ITypeParameter tp in typeDefinition.TypeParameters) {
+ decl.TypeParameters.Add(ConvertTypeParameter(tp));
+ }
+ }
+
+ if (this.ShowBaseTypes) {
+ foreach (ITypeReference baseType in typeDefinition.BaseTypes) {
+ decl.BaseTypes.Add(ConvertType(baseType.Resolve(context)));
+ }
+ }
+
+ if (this.ShowTypeParameters && this.ShowTypeParameterConstraints) {
+ foreach (ITypeParameter tp in typeDefinition.TypeParameters) {
+ var constraint = ConvertTypeParameterConstraint(tp);
+ if (constraint != null)
+ decl.Constraints.Add(constraint);
+ }
+ }
+ return decl;
+ }
+
+ DelegateDeclaration ConvertDelegate(IMethod invokeMethod, Modifiers modifiers)
+ {
+ ITypeDefinition d = invokeMethod.DeclaringTypeDefinition;
+
+ DelegateDeclaration decl = new DelegateDeclaration();
+ decl.Modifiers = modifiers;
+ decl.ReturnType = ConvertType(invokeMethod.ReturnType.Resolve(context));
+ decl.Name = d.Name;
+
+ if (this.ShowTypeParameters) {
+ foreach (ITypeParameter tp in d.TypeParameters) {
+ decl.TypeParameters.Add(ConvertTypeParameter(tp));
+ }
+ }
+
+ foreach (IParameter p in invokeMethod.Parameters) {
+ decl.Parameters.Add(ConvertParameter(p));
+ }
+
+ if (this.ShowTypeParameters && this.ShowTypeParameterConstraints) {
+ foreach (ITypeParameter tp in d.TypeParameters) {
+ var constraint = ConvertTypeParameterConstraint(tp);
+ if (constraint != null)
+ decl.Constraints.Add(constraint);
+ }
+ }
+ return decl;
+ }
+
+ AstNode ConvertField(IField field)
+ {
+ FieldDeclaration decl = new FieldDeclaration();
+ Modifiers m = GetMemberModifiers(field);
+ if (field.IsConst) {
+ m &= ~Modifiers.Static;
+ m |= Modifiers.Const;
+ } else if (field.IsReadOnly) {
+ m |= Modifiers.Readonly;
+ } else if (field.IsVolatile) {
+ m |= Modifiers.Volatile;
+ }
+ decl.Modifiers = m;
+ decl.ReturnType = ConvertType(field.ReturnType.Resolve(context));
+ Expression initializer = null;
+ if (field.IsConst && this.ShowConstantValues)
+ initializer = ConvertConstantValue(field.ConstantValue);
+ decl.Variables.Add(new VariableInitializer(field.Name, initializer));
+ return decl;
+ }
+
+ Accessor ConvertAccessor(IAccessor accessor)
+ {
+ if (accessor == null)
+ return Accessor.Null;
+ Accessor decl = new Accessor();
+ decl.Modifiers = ModifierFromAccessibility(accessor.Accessibility);
+ return decl;
+ }
+
+ PropertyDeclaration ConvertProperty(IProperty property)
+ {
+ PropertyDeclaration decl = new PropertyDeclaration();
+ decl.Modifiers = GetMemberModifiers(property);
+ decl.ReturnType = ConvertType(property.ReturnType.Resolve(context));
+ decl.Name = property.Name;
+ decl.Getter = ConvertAccessor(property.Getter);
+ decl.Setter = ConvertAccessor(property.Setter);
+ return decl;
+ }
+
+ IndexerDeclaration ConvertIndexer(IProperty indexer)
+ {
+ IndexerDeclaration decl = new IndexerDeclaration();
+ decl.Modifiers = GetMemberModifiers(indexer);
+ decl.ReturnType = ConvertType(indexer.ReturnType.Resolve(context));
+ foreach (IParameter p in indexer.Parameters) {
+ decl.Parameters.Add(ConvertParameter(p));
+ }
+ decl.Getter = ConvertAccessor(indexer.Getter);
+ decl.Setter = ConvertAccessor(indexer.Setter);
+ return decl;
+ }
+
+ EventDeclaration ConvertEvent(IEvent ev)
+ {
+ EventDeclaration decl = new EventDeclaration();
+ decl.Modifiers = GetMemberModifiers(ev);
+ decl.ReturnType = ConvertType(ev.ReturnType.Resolve(context));
+ decl.Variables.Add(new VariableInitializer(ev.Name));
+ return decl;
+ }
+
+ MethodDeclaration ConvertMethod(IMethod method)
+ {
+ MethodDeclaration decl = new MethodDeclaration();
+ decl.Modifiers = GetMemberModifiers(method);
+ decl.ReturnType = ConvertType(method.ReturnType.Resolve(context));
+ decl.Name = method.Name;
+
+ if (this.ShowTypeParameters) {
+ foreach (ITypeParameter tp in method.TypeParameters) {
+ decl.TypeParameters.Add(ConvertTypeParameter(tp));
+ }
+ }
+
+ foreach (IParameter p in method.Parameters) {
+ decl.Parameters.Add(ConvertParameter(p));
+ }
+
+ if (this.ShowTypeParameters && this.ShowTypeParameterConstraints) {
+ foreach (ITypeParameter tp in method.TypeParameters) {
+ var constraint = ConvertTypeParameterConstraint(tp);
+ if (constraint != null)
+ decl.Constraints.Add(constraint);
+ }
+ }
+ return decl;
+ }
+
+ AstNode ConvertOperator(IMethod op)
+ {
+ OperatorType? opType = OperatorDeclaration.GetOperatorType(op.Name);
+ if (opType == null)
+ return ConvertMethod(op);
+
+ OperatorDeclaration decl = new OperatorDeclaration();
+ decl.Modifiers = GetMemberModifiers(op);
+ decl.OperatorType = opType.Value;
+ decl.ReturnType = ConvertType(op.ReturnType.Resolve(context));
+ foreach (IParameter p in op.Parameters) {
+ decl.Parameters.Add(ConvertParameter(p));
+ }
+ return decl;
+ }
+
+ ConstructorDeclaration ConvertConstructor(IMethod ctor)
+ {
+ ConstructorDeclaration decl = new ConstructorDeclaration();
+ decl.Modifiers = GetMemberModifiers(ctor);
+ decl.Name = ctor.DeclaringTypeDefinition.Name;
+ foreach (IParameter p in ctor.Parameters) {
+ decl.Parameters.Add(ConvertParameter(p));
+ }
+ return decl;
+ }
+
+ DestructorDeclaration ConvertDestructor(IMethod dtor)
+ {
+ DestructorDeclaration decl = new DestructorDeclaration();
+ decl.Name = dtor.DeclaringTypeDefinition.Name;
+ return decl;
+ }
+ #endregion
+
+ #region Convert Modifiers
+ Modifiers ModifierFromAccessibility(Accessibility accessibility)
+ {
+ if (!this.ShowAccessibility)
+ return Modifiers.None;
+ switch (accessibility) {
+ case Accessibility.Private:
+ return Modifiers.Private;
+ case Accessibility.Public:
+ return Modifiers.Public;
+ case Accessibility.Protected:
+ return Modifiers.Protected;
+ case Accessibility.Internal:
+ return Modifiers.Internal;
+ case Accessibility.ProtectedOrInternal:
+ case Accessibility.ProtectedAndInternal:
+ return Modifiers.Protected | Modifiers.Internal;
+ default:
+ return Modifiers.None;
+ }
+ }
+
+ Modifiers GetMemberModifiers(IMember member)
+ {
+ Modifiers m = ModifierFromAccessibility(member.Accessibility);
+ if (this.ShowModifiers) {
+ if (member.IsStatic) {
+ m |= Modifiers.Static;
+ } else {
+ if (member.IsAbstract)
+ m |= Modifiers.Abstract;
+ if (member.IsOverride)
+ m |= Modifiers.Override;
+ if (member.IsVirtual && !member.IsAbstract && !member.IsOverride)
+ m |= Modifiers.Virtual;
+ if (member.IsSealed)
+ m |= Modifiers.Sealed;
+ }
+ if (member.IsShadowing)
+ m |= Modifiers.New;
+ }
+ return m;
+ }
+ #endregion
+
+ #region Convert Type Parameter
+ TypeParameterDeclaration ConvertTypeParameter(ITypeParameter tp)
+ {
+ TypeParameterDeclaration decl = new TypeParameterDeclaration();
+ decl.Variance = tp.Variance;
+ decl.Name = tp.Name;
+ return decl;
+ }
+
+ Constraint ConvertTypeParameterConstraint(ITypeParameter tp)
+ {
+ if (tp.Constraints.Count == 0 && !tp.HasDefaultConstructorConstraint && !tp.HasReferenceTypeConstraint && !tp.HasValueTypeConstraint) {
+ return null;
+ }
+ Constraint c = new Constraint();
+ c.TypeParameter = tp.Name;
+ if (tp.HasReferenceTypeConstraint) {
+ c.BaseTypes.Add(new PrimitiveType("class"));
+ } else if (tp.HasValueTypeConstraint) {
+ c.BaseTypes.Add(new PrimitiveType("struct"));
+ }
+ foreach (ITypeReference tr in tp.Constraints) {
+ c.BaseTypes.Add(ConvertType(tr.Resolve(context)));
+ }
+ if (tp.HasDefaultConstructorConstraint) {
+ c.BaseTypes.Add(new PrimitiveType("new"));
+ }
+ return c;
+ }
+ #endregion
}
}
diff --git a/src/Main/Base/Project/ICSharpCode.SharpDevelop.addin b/src/Main/Base/Project/ICSharpCode.SharpDevelop.addin
index 6c2e027bfb..83edcfc0dd 100755
--- a/src/Main/Base/Project/ICSharpCode.SharpDevelop.addin
+++ b/src/Main/Base/Project/ICSharpCode.SharpDevelop.addin
@@ -39,7 +39,7 @@
-
+
diff --git a/src/Main/Base/Project/Src/Services/AmbienceService/CSharpAmbience.cs b/src/Main/Base/Project/Src/Services/AmbienceService/CSharpAmbience.cs
index e2319ce2f9..37ab0bb557 100644
--- a/src/Main/Base/Project/Src/Services/AmbienceService/CSharpAmbience.cs
+++ b/src/Main/Base/Project/Src/Services/AmbienceService/CSharpAmbience.cs
@@ -2,7 +2,12 @@
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
+using System.IO;
+using System.Text;
+using ICSharpCode.NRefactory.CSharp;
+using ICSharpCode.NRefactory.CSharp.Refactoring;
using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.SharpDevelop.Parser;
namespace ICSharpCode.SharpDevelop
{
@@ -15,37 +20,36 @@ namespace ICSharpCode.SharpDevelop
public string ConvertEntity(IEntity e)
{
- throw new NotImplementedException();
- }
-
- public string ConvertParameter(IVariable v)
- {
- throw new NotImplementedException();
+ using (var ctx = ParserService.CurrentTypeResolveContext.Synchronize()) {
+ TypeSystemAstBuilder astBuilder = new TypeSystemAstBuilder(ctx);
+ var astNode = astBuilder.ConvertEntity(e);
+ CSharpFormattingOptions formatting = new CSharpFormattingOptions();
+ StringWriter writer = new StringWriter();
+ astNode.AcceptVisitor(new OutputVisitor(writer, formatting), null);
+ return writer.ToString().TrimEnd();
+ }
}
public string ConvertType(IType type)
{
- throw new NotImplementedException();
- }
-
- public string ConvertAccessibility(Accessibility accessibility)
- {
- throw new NotImplementedException();
+ using (var ctx = ParserService.CurrentTypeResolveContext.Synchronize()) {
+ TypeSystemAstBuilder astBuilder = new TypeSystemAstBuilder(ctx);
+ AstType astType = astBuilder.ConvertType(type);
+ CSharpFormattingOptions formatting = new CSharpFormattingOptions();
+ StringWriter writer = new StringWriter();
+ astType.AcceptVisitor(new OutputVisitor(writer, formatting), null);
+ return writer.ToString();
+ }
}
public string WrapAttribute(string attribute)
{
- throw new NotImplementedException();
+ return "[" + attribute + "]";
}
public string WrapComment(string comment)
{
- throw new NotImplementedException();
- }
-
- public string GetIntrinsicTypeName(string dotNetTypeName)
- {
- throw new NotImplementedException();
+ return "// " + comment;
}
}
}
diff --git a/src/Main/Base/Project/Src/Services/AmbienceService/IAmbience.cs b/src/Main/Base/Project/Src/Services/AmbienceService/IAmbience.cs
index 3f0f4330e6..df977c4603 100644
--- a/src/Main/Base/Project/Src/Services/AmbienceService/IAmbience.cs
+++ b/src/Main/Base/Project/Src/Services/AmbienceService/IAmbience.cs
@@ -82,14 +82,9 @@ namespace ICSharpCode.SharpDevelop
}
string ConvertEntity(IEntity e);
- string ConvertParameter(IVariable v);
string ConvertType(IType type);
- string ConvertAccessibility(Accessibility accessibility);
-
string WrapAttribute(string attribute);
string WrapComment(string comment);
-
- string GetIntrinsicTypeName(string dotNetTypeName);
}
}