← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to contrib/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs
1
 
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team
2
 
// 
3
 
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
4
 
// software and associated documentation files (the "Software"), to deal in the Software
5
 
// without restriction, including without limitation the rights to use, copy, modify, merge,
6
 
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
7
 
// to whom the Software is furnished to do so, subject to the following conditions:
8
 
// 
9
 
// The above copyright notice and this permission notice shall be included in all copies or
10
 
// substantial portions of the Software.
11
 
// 
12
 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
13
 
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
14
 
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
15
 
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
16
 
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
17
 
// DEALINGS IN THE SOFTWARE.
18
 
 
19
 
using System;
20
 
using System.IO;
21
 
using ICSharpCode.NRefactory.CSharp.Refactoring;
22
 
using ICSharpCode.NRefactory.TypeSystem;
23
 
using ICSharpCode.NRefactory.TypeSystem.Implementation;
24
 
 
25
 
namespace ICSharpCode.NRefactory.CSharp
26
 
{
27
 
        /// <summary>
28
 
        /// C# ambience.
29
 
        /// </summary>
30
 
        public class CSharpAmbience : IAmbience
31
 
        {
32
 
                public ConversionFlags ConversionFlags { get; set; }
33
 
                
34
 
                #region ConvertEntity
35
 
                public string ConvertEntity(IEntity entity)
36
 
                {
37
 
                        if (entity == null)
38
 
                                throw new ArgumentNullException("entity");
39
 
                        
40
 
                        StringWriter writer = new StringWriter();
41
 
                        ConvertEntity(entity, new TextWriterOutputFormatter(writer), FormattingOptionsFactory.CreateMono ());
42
 
                        return writer.ToString();
43
 
                }
44
 
                
45
 
                public void ConvertEntity(IEntity entity, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
46
 
                {
47
 
                        if (entity == null)
48
 
                                throw new ArgumentNullException("entity");
49
 
                        if (formatter == null)
50
 
                                throw new ArgumentNullException("formatter");
51
 
                        if (formattingPolicy == null)
52
 
                                throw new ArgumentNullException("options");
53
 
                        
54
 
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
55
 
                        EntityDeclaration node = astBuilder.ConvertEntity(entity);
56
 
                        PrintModifiers(node.Modifiers, formatter);
57
 
                        
58
 
                        if ((ConversionFlags & ConversionFlags.ShowDefinitionKeyword) == ConversionFlags.ShowDefinitionKeyword) {
59
 
                                if (node is TypeDeclaration) {
60
 
                                        switch (((TypeDeclaration)node).ClassType) {
61
 
                                                case ClassType.Class:
62
 
                                                        formatter.WriteKeyword("class");
63
 
                                                        break;
64
 
                                                case ClassType.Struct:
65
 
                                                        formatter.WriteKeyword("struct");
66
 
                                                        break;
67
 
                                                case ClassType.Interface:
68
 
                                                        formatter.WriteKeyword("interface");
69
 
                                                        break;
70
 
                                                case ClassType.Enum:
71
 
                                                        formatter.WriteKeyword("enum");
72
 
                                                        break;
73
 
                                                default:
74
 
                                                        throw new Exception("Invalid value for ClassType");
75
 
                                        }
76
 
                                        formatter.Space();
77
 
                                } else if (node is DelegateDeclaration) {
78
 
                                        formatter.WriteKeyword("delegate");
79
 
                                        formatter.Space();
80
 
                                } else if (node is EventDeclaration) {
81
 
                                        formatter.WriteKeyword("event");
82
 
                                        formatter.Space();
83
 
                                }
84
 
                        }
85
 
                        
86
 
                        if ((ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType) {
87
 
                                var rt = node.GetChildByRole(Roles.Type);
88
 
                                if (!rt.IsNull) {
89
 
                                        rt.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
90
 
                                        formatter.Space();
91
 
                                }
92
 
                        }
93
 
                        
94
 
                        if (entity is ITypeDefinition)
95
 
                                WriteTypeDeclarationName((ITypeDefinition)entity, formatter, formattingPolicy);
96
 
                        else
97
 
                                WriteMemberDeclarationName((IMember)entity, formatter, formattingPolicy);
98
 
                        
99
 
                        if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList && HasParameters(entity)) {
100
 
                                formatter.WriteToken(entity.EntityType == EntityType.Indexer ? "[" : "(");
101
 
                                bool first = true;
102
 
                                foreach (var param in node.GetChildrenByRole(Roles.Parameter)) {
103
 
                                        if (first) {
104
 
                                                first = false;
105
 
                                        } else {
106
 
                                                formatter.WriteToken(",");
107
 
                                                formatter.Space();
108
 
                                        }
109
 
                                        param.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
110
 
                                }
111
 
                                formatter.WriteToken(entity.EntityType == EntityType.Indexer ? "]" : ")");
112
 
                        }
113
 
                        
114
 
                        if ((ConversionFlags & ConversionFlags.ShowBody) == ConversionFlags.ShowBody && !(node is TypeDeclaration)) {
115
 
                                IProperty property = entity as IProperty;
116
 
                                if (property != null) {
117
 
                                        formatter.Space();
118
 
                                        formatter.WriteToken("{");
119
 
                                        formatter.Space();
120
 
                                        if (property.CanGet) {
121
 
                                                formatter.WriteKeyword("get");
122
 
                                                formatter.WriteToken(";");
123
 
                                                formatter.Space();
124
 
                                        }
125
 
                                        if (property.CanSet) {
126
 
                                                formatter.WriteKeyword("set");
127
 
                                                formatter.WriteToken(";");
128
 
                                                formatter.Space();
129
 
                                        }
130
 
                                        formatter.WriteToken("}");
131
 
                                } else {
132
 
                                        formatter.WriteToken(";");
133
 
                                }
134
 
                        }
135
 
                }
136
 
                
137
 
                bool HasParameters(IEntity e)
138
 
                {
139
 
                        switch (e.EntityType) {
140
 
                                case EntityType.TypeDefinition:
141
 
                                        return ((ITypeDefinition)e).Kind == TypeKind.Delegate;
142
 
                                case EntityType.Indexer:
143
 
                                case EntityType.Method:
144
 
                                case EntityType.Operator:
145
 
                                case EntityType.Constructor:
146
 
                                case EntityType.Destructor:
147
 
                                        return true;
148
 
                                default:
149
 
                                        return false;
150
 
                        }
151
 
                }
152
 
                
153
 
                TypeSystemAstBuilder CreateAstBuilder()
154
 
                {
155
 
                        TypeSystemAstBuilder astBuilder = new TypeSystemAstBuilder();
156
 
                        astBuilder.AddAnnotations = true;
157
 
                        astBuilder.ShowModifiers = (ConversionFlags & ConversionFlags.ShowModifiers) == ConversionFlags.ShowModifiers;
158
 
                        astBuilder.ShowAccessibility = (ConversionFlags & ConversionFlags.ShowAccessibility) == ConversionFlags.ShowAccessibility;
159
 
                        astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedTypeNames) != ConversionFlags.UseFullyQualifiedTypeNames;
160
 
                        astBuilder.ShowParameterNames = (ConversionFlags & ConversionFlags.ShowParameterNames) == ConversionFlags.ShowParameterNames;
161
 
                        return astBuilder;
162
 
                }
163
 
                
164
 
                void WriteTypeDeclarationName(ITypeDefinition typeDef, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
165
 
                {
166
 
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
167
 
                        if (typeDef.DeclaringTypeDefinition != null) {
168
 
                                WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, formatter, formattingPolicy);
169
 
                                formatter.WriteToken(".");
170
 
                        } else if ((ConversionFlags & ConversionFlags.UseFullyQualifiedTypeNames) == ConversionFlags.UseFullyQualifiedTypeNames) {
171
 
                                formatter.WriteIdentifier(typeDef.Namespace);
172
 
                                formatter.WriteToken(".");
173
 
                        }
174
 
                        formatter.WriteIdentifier(typeDef.Name);
175
 
                        if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList) {
176
 
                                var outputVisitor = new CSharpOutputVisitor(formatter, formattingPolicy);
177
 
                                outputVisitor.WriteTypeParameters(astBuilder.ConvertEntity(typeDef).GetChildrenByRole(Roles.TypeParameter));
178
 
                        }
179
 
                }
180
 
                
181
 
                void WriteMemberDeclarationName(IMember member, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
182
 
                {
183
 
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
184
 
                        if ((ConversionFlags & ConversionFlags.ShowDeclaringType) == ConversionFlags.ShowDeclaringType) {
185
 
                                ConvertType(member.DeclaringType, formatter, formattingPolicy);
186
 
                                formatter.WriteToken(".");
187
 
                        }
188
 
                        switch (member.EntityType) {
189
 
                                case EntityType.Indexer:
190
 
                                        formatter.WriteKeyword("this");
191
 
                                        break;
192
 
                                case EntityType.Constructor:
193
 
                                        formatter.WriteIdentifier(member.DeclaringType.Name);
194
 
                                        break;
195
 
                                case EntityType.Destructor:
196
 
                                        formatter.WriteToken("~");
197
 
                                        formatter.WriteIdentifier(member.DeclaringType.Name);
198
 
                                        break;
199
 
                                case EntityType.Operator:
200
 
                                        switch (member.Name) {
201
 
                                                case "op_Implicit":
202
 
                                                        formatter.WriteKeyword("implicit");
203
 
                                                        formatter.Space();
204
 
                                                        formatter.WriteKeyword("operator");
205
 
                                                        formatter.Space();
206
 
                                                        ConvertType(member.ReturnType, formatter, formattingPolicy);
207
 
                                                        break;
208
 
                                                case "op_Explicit":
209
 
                                                        formatter.WriteKeyword("explicit");
210
 
                                                        formatter.Space();
211
 
                                                        formatter.WriteKeyword("operator");
212
 
                                                        formatter.Space();
213
 
                                                        ConvertType(member.ReturnType, formatter, formattingPolicy);
214
 
                                                        break;
215
 
                                                default:
216
 
                                                        formatter.WriteKeyword("operator");
217
 
                                                        formatter.Space();
218
 
                                                        var operatorType = OperatorDeclaration.GetOperatorType(member.Name);
219
 
                                                        if (operatorType.HasValue)
220
 
                                                                formatter.WriteToken(OperatorDeclaration.GetToken(operatorType.Value));
221
 
                                                        else
222
 
                                                                formatter.WriteIdentifier(member.Name);
223
 
                                                        break;
224
 
                                        }
225
 
                                        break;
226
 
                                default:
227
 
                                        formatter.WriteIdentifier(member.Name);
228
 
                                        break;
229
 
                        }
230
 
                        if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList && member.EntityType == EntityType.Method) {
231
 
                                var outputVisitor = new CSharpOutputVisitor(formatter, formattingPolicy);
232
 
                                outputVisitor.WriteTypeParameters(astBuilder.ConvertEntity(member).GetChildrenByRole(Roles.TypeParameter));
233
 
                        }
234
 
                }
235
 
                
236
 
                void PrintModifiers(Modifiers modifiers, IOutputFormatter formatter)
237
 
                {
238
 
                        foreach (var m in CSharpModifierToken.AllModifiers) {
239
 
                                if ((modifiers & m) == m) {
240
 
                                        formatter.WriteKeyword(CSharpModifierToken.GetModifierName(m));
241
 
                                        formatter.Space();
242
 
                                }
243
 
                        }
244
 
                }
245
 
                #endregion
246
 
                
247
 
                public string ConvertVariable(IVariable v)
248
 
                {
249
 
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
250
 
                        AstNode astNode = astBuilder.ConvertVariable(v);
251
 
                        return astNode.GetText().TrimEnd(';', '\r', '\n');
252
 
                }
253
 
                
254
 
                public string ConvertType(IType type)
255
 
                {
256
 
                        if (type == null)
257
 
                                throw new ArgumentNullException("type");
258
 
                        
259
 
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
260
 
                        AstType astType = astBuilder.ConvertType(type);
261
 
                        return astType.GetText();
262
 
                }
263
 
                
264
 
                public void ConvertType(IType type, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
265
 
                {
266
 
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
267
 
                        AstType astType = astBuilder.ConvertType(type);
268
 
                        astType.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
269
 
                }
270
 
                
271
 
                public string WrapComment(string comment)
272
 
                {
273
 
                        return "// " + comment;
274
 
                }
275
 
        }
276
 
}