← Back to branch summary

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

« back to all changes in this revision

Viewing changes to external/nrefactory/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:
external/nrefactory/ICSharpCode.NRefactory.CSharp/OutputVisitor/CSharpAmbience.cs
 
1
// Copyright (c) 2010-2013 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
 
 
24
namespace ICSharpCode.NRefactory.CSharp
 
25
{
 
26
        /// <summary>
 
27
        /// C# ambience.
 
28
        /// </summary>
 
29
        public class CSharpAmbience : IAmbience
 
30
        {
 
31
                public ConversionFlags ConversionFlags { get; set; }
 
32
                
 
33
                #region ConvertEntity
 
34
                public string ConvertEntity(IEntity entity)
 
35
                {
 
36
                        if (entity == null)
 
37
                                throw new ArgumentNullException("entity");
 
38
                        
 
39
                        StringWriter writer = new StringWriter();
 
40
                        ConvertEntity(entity, new TextWriterOutputFormatter(writer), FormattingOptionsFactory.CreateMono ());
 
41
                        return writer.ToString();
 
42
                }
 
43
                
 
44
                public void ConvertEntity(IEntity entity, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
 
45
                {
 
46
                        if (entity == null)
 
47
                                throw new ArgumentNullException("entity");
 
48
                        if (formatter == null)
 
49
                                throw new ArgumentNullException("formatter");
 
50
                        if (formattingPolicy == null)
 
51
                                throw new ArgumentNullException("options");
 
52
                        
 
53
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 
54
                        EntityDeclaration node = astBuilder.ConvertEntity(entity);
 
55
                        PrintModifiers(node.Modifiers, formatter);
 
56
                        
 
57
                        if ((ConversionFlags & ConversionFlags.ShowDefinitionKeyword) == ConversionFlags.ShowDefinitionKeyword) {
 
58
                                if (node is TypeDeclaration) {
 
59
                                        switch (((TypeDeclaration)node).ClassType) {
 
60
                                                case ClassType.Class:
 
61
                                                        formatter.WriteKeyword("class");
 
62
                                                        break;
 
63
                                                case ClassType.Struct:
 
64
                                                        formatter.WriteKeyword("struct");
 
65
                                                        break;
 
66
                                                case ClassType.Interface:
 
67
                                                        formatter.WriteKeyword("interface");
 
68
                                                        break;
 
69
                                                case ClassType.Enum:
 
70
                                                        formatter.WriteKeyword("enum");
 
71
                                                        break;
 
72
                                                default:
 
73
                                                        throw new Exception("Invalid value for ClassType");
 
74
                                        }
 
75
                                        formatter.Space();
 
76
                                } else if (node is DelegateDeclaration) {
 
77
                                        formatter.WriteKeyword("delegate");
 
78
                                        formatter.Space();
 
79
                                } else if (node is EventDeclaration) {
 
80
                                        formatter.WriteKeyword("event");
 
81
                                        formatter.Space();
 
82
                                }
 
83
                        }
 
84
                        
 
85
                        if ((ConversionFlags & ConversionFlags.ShowReturnType) == ConversionFlags.ShowReturnType) {
 
86
                                var rt = node.GetChildByRole(Roles.Type);
 
87
                                if (!rt.IsNull) {
 
88
                                        rt.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
 
89
                                        formatter.Space();
 
90
                                }
 
91
                        }
 
92
                        
 
93
                        if (entity is ITypeDefinition)
 
94
                                WriteTypeDeclarationName((ITypeDefinition)entity, formatter, formattingPolicy);
 
95
                        else
 
96
                                WriteMemberDeclarationName((IMember)entity, formatter, formattingPolicy);
 
97
                        
 
98
                        if ((ConversionFlags & ConversionFlags.ShowParameterList) == ConversionFlags.ShowParameterList && HasParameters(entity)) {
 
99
                                formatter.WriteToken(entity.EntityType == EntityType.Indexer ? "[" : "(");
 
100
                                bool first = true;
 
101
                                foreach (var param in node.GetChildrenByRole(Roles.Parameter)) {
 
102
                                        if (first) {
 
103
                                                first = false;
 
104
                                        } else {
 
105
                                                formatter.WriteToken(",");
 
106
                                                formatter.Space();
 
107
                                        }
 
108
                                        param.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
 
109
                                }
 
110
                                formatter.WriteToken(entity.EntityType == EntityType.Indexer ? "]" : ")");
 
111
                        }
 
112
                        
 
113
                        if ((ConversionFlags & ConversionFlags.ShowBody) == ConversionFlags.ShowBody && !(node is TypeDeclaration)) {
 
114
                                IProperty property = entity as IProperty;
 
115
                                if (property != null) {
 
116
                                        formatter.Space();
 
117
                                        formatter.WriteToken("{");
 
118
                                        formatter.Space();
 
119
                                        if (property.CanGet) {
 
120
                                                formatter.WriteKeyword("get");
 
121
                                                formatter.WriteToken(";");
 
122
                                                formatter.Space();
 
123
                                        }
 
124
                                        if (property.CanSet) {
 
125
                                                formatter.WriteKeyword("set");
 
126
                                                formatter.WriteToken(";");
 
127
                                                formatter.Space();
 
128
                                        }
 
129
                                        formatter.WriteToken("}");
 
130
                                } else {
 
131
                                        formatter.WriteToken(";");
 
132
                                }
 
133
                        }
 
134
                }
 
135
                
 
136
                bool HasParameters(IEntity e)
 
137
                {
 
138
                        switch (e.EntityType) {
 
139
                                case EntityType.TypeDefinition:
 
140
                                        return ((ITypeDefinition)e).Kind == TypeKind.Delegate;
 
141
                                case EntityType.Indexer:
 
142
                                case EntityType.Method:
 
143
                                case EntityType.Operator:
 
144
                                case EntityType.Constructor:
 
145
                                case EntityType.Destructor:
 
146
                                        return true;
 
147
                                default:
 
148
                                        return false;
 
149
                        }
 
150
                }
 
151
                
 
152
                TypeSystemAstBuilder CreateAstBuilder()
 
153
                {
 
154
                        TypeSystemAstBuilder astBuilder = new TypeSystemAstBuilder();
 
155
                        astBuilder.AddAnnotations = true;
 
156
                        astBuilder.ShowModifiers = (ConversionFlags & ConversionFlags.ShowModifiers) == ConversionFlags.ShowModifiers;
 
157
                        astBuilder.ShowAccessibility = (ConversionFlags & ConversionFlags.ShowAccessibility) == ConversionFlags.ShowAccessibility;
 
158
                        astBuilder.AlwaysUseShortTypeNames = (ConversionFlags & ConversionFlags.UseFullyQualifiedTypeNames) != ConversionFlags.UseFullyQualifiedTypeNames;
 
159
                        astBuilder.ShowParameterNames = (ConversionFlags & ConversionFlags.ShowParameterNames) == ConversionFlags.ShowParameterNames;
 
160
                        return astBuilder;
 
161
                }
 
162
                
 
163
                void WriteTypeDeclarationName(ITypeDefinition typeDef, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
 
164
                {
 
165
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 
166
                        if (typeDef.DeclaringTypeDefinition != null) {
 
167
                                WriteTypeDeclarationName(typeDef.DeclaringTypeDefinition, formatter, formattingPolicy);
 
168
                                formatter.WriteToken(".");
 
169
                        } else if ((ConversionFlags & ConversionFlags.UseFullyQualifiedTypeNames) == ConversionFlags.UseFullyQualifiedTypeNames) {
 
170
                                formatter.WriteIdentifier(typeDef.Namespace);
 
171
                                formatter.WriteToken(".");
 
172
                        }
 
173
                        formatter.WriteIdentifier(typeDef.Name);
 
174
                        if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList) {
 
175
                                var outputVisitor = new CSharpOutputVisitor(formatter, formattingPolicy);
 
176
                                outputVisitor.WriteTypeParameters(astBuilder.ConvertEntity(typeDef).GetChildrenByRole(Roles.TypeParameter));
 
177
                        }
 
178
                }
 
179
                
 
180
                void WriteMemberDeclarationName(IMember member, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
 
181
                {
 
182
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 
183
                        if ((ConversionFlags & ConversionFlags.ShowDeclaringType) == ConversionFlags.ShowDeclaringType) {
 
184
                                ConvertType(member.DeclaringType, formatter, formattingPolicy);
 
185
                                formatter.WriteToken(".");
 
186
                        }
 
187
                        switch (member.EntityType) {
 
188
                                case EntityType.Indexer:
 
189
                                        formatter.WriteKeyword("this");
 
190
                                        break;
 
191
                                case EntityType.Constructor:
 
192
                                        formatter.WriteIdentifier(member.DeclaringType.Name);
 
193
                                        break;
 
194
                                case EntityType.Destructor:
 
195
                                        formatter.WriteToken("~");
 
196
                                        formatter.WriteIdentifier(member.DeclaringType.Name);
 
197
                                        break;
 
198
                                case EntityType.Operator:
 
199
                                        switch (member.Name) {
 
200
                                                case "op_Implicit":
 
201
                                                        formatter.WriteKeyword("implicit");
 
202
                                                        formatter.Space();
 
203
                                                        formatter.WriteKeyword("operator");
 
204
                                                        formatter.Space();
 
205
                                                        ConvertType(member.ReturnType, formatter, formattingPolicy);
 
206
                                                        break;
 
207
                                                case "op_Explicit":
 
208
                                                        formatter.WriteKeyword("explicit");
 
209
                                                        formatter.Space();
 
210
                                                        formatter.WriteKeyword("operator");
 
211
                                                        formatter.Space();
 
212
                                                        ConvertType(member.ReturnType, formatter, formattingPolicy);
 
213
                                                        break;
 
214
                                                default:
 
215
                                                        formatter.WriteKeyword("operator");
 
216
                                                        formatter.Space();
 
217
                                                        var operatorType = OperatorDeclaration.GetOperatorType(member.Name);
 
218
                                                        if (operatorType.HasValue)
 
219
                                                                formatter.WriteToken(OperatorDeclaration.GetToken(operatorType.Value));
 
220
                                                        else
 
221
                                                                formatter.WriteIdentifier(member.Name);
 
222
                                                        break;
 
223
                                        }
 
224
                                        break;
 
225
                                default:
 
226
                                        formatter.WriteIdentifier(member.Name);
 
227
                                        break;
 
228
                        }
 
229
                        if ((ConversionFlags & ConversionFlags.ShowTypeParameterList) == ConversionFlags.ShowTypeParameterList && member.EntityType == EntityType.Method) {
 
230
                                var outputVisitor = new CSharpOutputVisitor(formatter, formattingPolicy);
 
231
                                outputVisitor.WriteTypeParameters(astBuilder.ConvertEntity(member).GetChildrenByRole(Roles.TypeParameter));
 
232
                        }
 
233
                }
 
234
                
 
235
                void PrintModifiers(Modifiers modifiers, IOutputFormatter formatter)
 
236
                {
 
237
                        foreach (var m in CSharpModifierToken.AllModifiers) {
 
238
                                if ((modifiers & m) == m) {
 
239
                                        formatter.WriteKeyword(CSharpModifierToken.GetModifierName(m));
 
240
                                        formatter.Space();
 
241
                                }
 
242
                        }
 
243
                }
 
244
                #endregion
 
245
                
 
246
                public string ConvertVariable(IVariable v)
 
247
                {
 
248
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 
249
                        AstNode astNode = astBuilder.ConvertVariable(v);
 
250
                        return astNode.GetText().TrimEnd(';', '\r', '\n');
 
251
                }
 
252
                
 
253
                public string ConvertType(IType type)
 
254
                {
 
255
                        if (type == null)
 
256
                                throw new ArgumentNullException("type");
 
257
                        
 
258
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 
259
                        AstType astType = astBuilder.ConvertType(type);
 
260
                        return astType.GetText();
 
261
                }
 
262
                
 
263
                public void ConvertType(IType type, IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
 
264
                {
 
265
                        TypeSystemAstBuilder astBuilder = CreateAstBuilder();
 
266
                        AstType astType = astBuilder.ConvertType(type);
 
267
                        astType.AcceptVisitor(new CSharpOutputVisitor(formatter, formattingPolicy));
 
268
                }
 
269
                
 
270
                public string WrapComment(string comment)
 
271
                {
 
272
                        return "// " + comment;
 
273
                }
 
274
        }
 
275
}