~ubuntu-branches/ubuntu/oneiric/monodevelop/oneiric

« back to all changes in this revision

Viewing changes to src/addins/CSharpBinding/MonoDevelop.CSharp.Parser/CSharpParser.cs

  • Committer: Bazaar Package Importer
  • Author(s): Jo Shields
  • Date: 2011-06-27 17:03:13 UTC
  • mto: (1.8.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 54.
  • Revision ID: james.westby@ubuntu.com-20110627170313-6cvz3s19x6e9hqe9
ImportĀ upstreamĀ versionĀ 2.5.92+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
23
23
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24
24
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25
25
// THE SOFTWARE.
26
 
/*
 
26
 
27
27
using System;
28
28
using System.Linq;
29
29
using System.Collections.Generic;
31
31
using Mono.CSharp;
32
32
using System.Text;
33
33
using Mono.TextEditor;
34
 
using MonoDevelop.CSharp.Dom;
 
34
using MonoDevelop.CSharp.Ast;
35
35
using MonoDevelop.Projects.Dom;
36
36
 
37
37
namespace MonoDevelop.CSharp.Parser
38
38
{
39
39
        public class CSharpParser
40
40
        {
41
 
                class ConversionVisitor : AbstractStructuralVisitor
 
41
                class ConversionVisitor : StructuralVisitor
42
42
                {
43
 
                        MonoDevelop.CSharp.Dom.CompilationUnit unit = new MonoDevelop.CSharp.Dom.CompilationUnit ();
 
43
                        MonoDevelop.CSharp.Ast.CompilationUnit unit = new MonoDevelop.CSharp.Ast.CompilationUnit ();
44
44
                        
45
 
                        public MonoDevelop.CSharp.Dom.CompilationUnit Unit {
 
45
                        public MonoDevelop.CSharp.Ast.CompilationUnit Unit {
46
46
                                get {
47
47
                                        return unit;
48
48
                                }
51
51
                                }
52
52
                        }
53
53
                        
54
 
                        public LocationStorage LocationStorage  {
 
54
                        public LocationsBag LocationsBag  {
55
55
                                get;
56
56
                                private set;
57
57
                        }
58
58
                        
59
 
                        public ConversionVisitor (LocationStorage locationStorage)
 
59
                        public ConversionVisitor (LocationsBag locationsBag)
60
60
                        {
61
 
                                this.LocationStorage = locationStorage;
 
61
                                this.LocationsBag = locationsBag;
62
62
                        }
63
63
                        
64
 
                        public static DomLocation Convert (Mono.CSharp.Location loc)
 
64
                        public static AstLocation Convert (Mono.CSharp.Location loc)
65
65
                        {
66
 
                                return new DomLocation (loc.Row - 1, loc.Column - 1);
 
66
                                return new AstLocation (loc.Row, loc.Column);
67
67
                        }
68
68
                        
69
69
                        #region Global
70
 
                        public override void Visit (ModuleCompiled mc)
71
 
                        {
72
 
                                base.Visit (mc);
73
 
                        }
74
 
 
 
70
                        Stack<NamespaceDeclaration> namespaceStack = new Stack<NamespaceDeclaration> ();
 
71
                        
 
72
                        void AddTypeArguments (ATypeNameExpression texpr, AstType result)
 
73
                        {
 
74
                                if (!texpr.HasTypeArguments)
 
75
                                        return;
 
76
                                foreach (var arg in texpr.TypeArguments.Args) {
 
77
                                        result.AddChild (ConvertToType (arg), AstType.Roles.TypeArgument);
 
78
                                }
 
79
                        }
 
80
                        
 
81
                        AstType ConvertToType (Mono.CSharp.Expression typeName)
 
82
                        {
 
83
                                if (typeName is TypeExpression) {
 
84
                                        var typeExpr = (Mono.CSharp.TypeExpression)typeName;
 
85
                                        return new PrimitiveType (typeExpr.GetSignatureForError (), Convert (typeExpr.Location));
 
86
                                }
 
87
                                
 
88
                                if (typeName is Mono.CSharp.QualifiedAliasMember) {
 
89
                                        var qam = (Mono.CSharp.QualifiedAliasMember)typeName;
 
90
                                        var memberType = new MonoDevelop.CSharp.Ast.MemberType ();
 
91
                                        if (qam.LeftExpression == null) {
 
92
                                                memberType.Target = new SimpleType ("global", Convert (qam.Location));
 
93
                                        } else { 
 
94
                                                memberType.Target = ConvertToType (qam.LeftExpression);
 
95
                                        }
 
96
                                        memberType.IsDoubleColon = true;
 
97
                                        memberType.MemberName = qam.Name;
 
98
                                        return memberType;
 
99
                                }
 
100
                                
 
101
                                if (typeName is MemberAccess) {
 
102
                                        MemberAccess ma = (MemberAccess)typeName;
 
103
                                        
 
104
                                        var memberType = new MonoDevelop.CSharp.Ast.MemberType ();
 
105
                                        memberType.AddChild (ConvertToType (ma.LeftExpression), MonoDevelop.CSharp.Ast.MemberType.TargetRole);
 
106
                                        memberType.MemberName = ma.Name;
 
107
                                        
 
108
                                        AddTypeArguments (ma, memberType);
 
109
                                        return memberType;
 
110
                                }
 
111
                                
 
112
                                if (typeName is SimpleName) {
 
113
                                        var sn = (SimpleName)typeName;
 
114
                                        var result = new SimpleType (sn.Name, Convert (sn.Location));
 
115
                                        AddTypeArguments (sn, result);
 
116
                                        return result;
 
117
                                }
 
118
                                
 
119
                                if (typeName is ComposedCast) {
 
120
                                        var cc = (ComposedCast)typeName;
 
121
                                        var baseType = ConvertToType (cc.Left);
 
122
                                        var result = new ComposedType () { BaseType = baseType };
 
123
                                        
 
124
                                        if (cc.Spec.IsNullable) {
 
125
                                                result.HasNullableSpecifier = true;
 
126
                                        } else if (cc.Spec.IsPointer) {
 
127
                                                result.PointerRank++;
 
128
                                        } else {
 
129
                                                var location = LocationsBag.GetLocations (cc.Spec);
 
130
                                                var spec = new ArraySpecifier () { Dimensions = cc.Spec.Dimension };
 
131
                                                spec.AddChild (new CSharpTokenNode (Convert (cc.Spec.Location), 1), FieldDeclaration.Roles.LBracket);
 
132
                                                if (location != null)
 
133
                                                        spec.AddChild (new CSharpTokenNode (Convert (location [0]), 1), FieldDeclaration.Roles.RBracket);
 
134
                                                
 
135
                                                result.AddChild (spec, ComposedType.ArraySpecifierRole);
 
136
                                        }
 
137
                                        return result;
 
138
                                }
 
139
                                
 
140
                                System.Console.WriteLine ("Error while converting :" + typeName + " - unknown type name");
 
141
                                System.Console.WriteLine (Environment.StackTrace);
 
142
                                return new SimpleType ("unknown");
 
143
                        }
 
144
                        
 
145
                        public override void Visit (UsingsBag.Namespace nspace)
 
146
                        {
 
147
                                NamespaceDeclaration nDecl = null;
 
148
                                if (nspace.Name != null) {
 
149
                                        nDecl = new NamespaceDeclaration ();
 
150
                                        nDecl.AddChild (new CSharpTokenNode (Convert (nspace.NamespaceLocation), "namespace".Length), NamespaceDeclaration.Roles.Keyword);
 
151
                                        ConvertNamespaceName (nspace.Name, nDecl);
 
152
                                        nDecl.AddChild (new CSharpTokenNode (Convert (nspace.OpenBrace), 1), NamespaceDeclaration.Roles.LBrace);
 
153
                                        AddToNamespace (nDecl);
 
154
                                        namespaceStack.Push (nDecl);
 
155
                                        
 
156
                                }
 
157
                                VisitNamespaceUsings (nspace);
 
158
                                VisitNamespaceBody (nspace);
 
159
                                
 
160
                                if (nDecl != null) {
 
161
                                        nDecl.AddChild (new CSharpTokenNode (Convert (nspace.CloseBrace), 1), NamespaceDeclaration.Roles.RBrace);
 
162
                                        if (!nspace.OptSemicolon.IsNull)
 
163
                                                nDecl.AddChild (new CSharpTokenNode (Convert (nspace.OptSemicolon), 1), NamespaceDeclaration.Roles.Semicolon);
 
164
                                        
 
165
                                        namespaceStack.Pop ();
 
166
                                }
 
167
                        }
 
168
                        
 
169
                        void ConvertNamespaceName (MemberName memberName, NamespaceDeclaration namespaceDecl)
 
170
                        {
 
171
                                AstNode insertPos = null;
 
172
                                while (memberName != null) {
 
173
                                        Identifier newIdent = CreateIdentifier (memberName.Name, Convert (memberName.Location));
 
174
                                        namespaceDecl.InsertChildBefore (insertPos, newIdent, NamespaceDeclaration.Roles.Identifier);
 
175
                                        insertPos = newIdent;
 
176
                                        memberName = memberName.Left;
 
177
                                }
 
178
                        }
 
179
                        
 
180
                        public override void Visit (UsingsBag.Using u)
 
181
                        {
 
182
                                UsingDeclaration ud = new UsingDeclaration ();
 
183
                                ud.AddChild (new CSharpTokenNode (Convert (u.UsingLocation), "using".Length), UsingDeclaration.Roles.Keyword);
 
184
                                ud.AddChild (ConvertImport (u.NSpace), UsingDeclaration.ImportRole);
 
185
                                ud.AddChild (new CSharpTokenNode (Convert (u.SemicolonLocation), 1), UsingDeclaration.Roles.Semicolon);
 
186
                                AddToNamespace (ud);
 
187
                        }
 
188
                        
 
189
                        public override void Visit (UsingsBag.AliasUsing u)
 
190
                        {
 
191
                                UsingAliasDeclaration ud = new UsingAliasDeclaration ();
 
192
                                ud.AddChild (new CSharpTokenNode (Convert (u.UsingLocation), "using".Length), UsingAliasDeclaration.Roles.Keyword);
 
193
                                ud.AddChild (CreateIdentifier (u.Identifier.Value, Convert (u.Identifier.Location)), UsingAliasDeclaration.AliasRole);
 
194
                                ud.AddChild (new CSharpTokenNode (Convert (u.AssignLocation), 1), UsingAliasDeclaration.Roles.Assign);
 
195
                                ud.AddChild (ConvertImport (u.Nspace), UsingAliasDeclaration.ImportRole);
 
196
                                ud.AddChild (new CSharpTokenNode (Convert (u.SemicolonLocation), 1), UsingAliasDeclaration.Roles.Semicolon);
 
197
                                AddToNamespace (ud);
 
198
                        }
 
199
                        
 
200
                        AstType ConvertImport (MemberName memberName)
 
201
                        {
 
202
                                if (memberName.Left != null) {
 
203
                                        // left.name
 
204
                                        var t = new MonoDevelop.CSharp.Ast.MemberType();
 
205
                                        t.IsDoubleColon = memberName.IsDoubleColon;
 
206
                                        t.AddChild (ConvertImport (memberName.Left), MonoDevelop.CSharp.Ast.MemberType.TargetRole);
 
207
                                        t.AddChild (CreateIdentifier (memberName.Name, Convert(memberName.Location)), MonoDevelop.CSharp.Ast.MemberType.Roles.Identifier);
 
208
                                        return t;
 
209
                                } else {
 
210
                                        SimpleType t = new SimpleType();
 
211
                                        t.AddChild (CreateIdentifier (memberName.Name, Convert(memberName.Location)), SimpleType.Roles.Identifier);
 
212
                                        // TODO type arguments
 
213
                                        return t;
 
214
                                }
 
215
                        }
 
216
                        
75
217
                        public override void Visit (MemberCore member)
76
218
                        {
77
219
                                Console.WriteLine ("Unknown member:");
83
225
                        public override void Visit (Class c)
84
226
                        {
85
227
                                TypeDeclaration newType = new TypeDeclaration ();
86
 
                                newType.ClassType = MonoDevelop.Projects.Dom.ClassType.Class;
 
228
                                newType.ClassType = ClassType.Class;
87
229
                                
88
 
                                LocationDescriptor location = LocationStorage.Get (c);
 
230
                                var location = LocationsBag.GetMemberLocation (c);
89
231
                                AddModifiers (newType, location);
90
 
                                newType.AddChild (new CSharpTokenNode (Convert (location[0]), "class".Length), TypeDeclaration.TypeKeyword);
91
 
                                newType.AddChild (new Identifier (c.Name, Convert (location[1])), AbstractNode.Roles.Identifier);
 
232
                                if (location != null)
 
233
                                        newType.AddChild (new CSharpTokenNode (Convert (location[0]), "class".Length), TypeDeclaration.Roles.Keyword);
 
234
                                newType.AddChild (CreateIdentifier (c.Basename, Convert (c.MemberName.Location)), AstNode.Roles.Identifier);
92
235
                                if (c.MemberName.TypeArguments != null)  {
93
 
                                        LocationDescriptor typeArgLocation = LocationStorage.Get (c.MemberName);
94
 
                                        newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), MemberReferenceExpression.Roles.LChevron);
95
 
                                        AddTypeArguments (newType, typeArgLocation, c.MemberName.TypeArguments);
96
 
                                        newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), MemberReferenceExpression.Roles.RChevron);
 
236
                                        var typeArgLocation = LocationsBag.GetLocations (c.MemberName);
 
237
                                        if (typeArgLocation != null)
 
238
                                                newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), TypeDeclaration.Roles.LChevron);
 
239
                                        AddTypeParameters (newType, typeArgLocation, c.MemberName.TypeArguments);
 
240
                                        if (typeArgLocation != null)
 
241
                                                newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), TypeDeclaration.Roles.RChevron);
97
242
                                        AddConstraints (newType, c);
98
243
                                }
99
 
                                
100
 
                                newType.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AbstractCSharpNode.Roles.LBrace);
 
244
                                if (location != null && location.Count > 1)
 
245
                                        newType.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AstNode.Roles.LBrace);
101
246
                                typeStack.Push (newType);
102
247
                                base.Visit (c);
103
 
                                newType.AddChild (new CSharpTokenNode  (Convert (location[3]), 1), AbstractCSharpNode.Roles.RBrace);
 
248
                                if (location != null && location.Count > 2)
 
249
                                        newType.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AstNode.Roles.RBrace);
104
250
                                typeStack.Pop ();
105
251
                                AddType (newType);
106
252
                        }
108
254
                        public override void Visit (Struct s)
109
255
                        {
110
256
                                TypeDeclaration newType = new TypeDeclaration ();
111
 
                                newType.ClassType = MonoDevelop.Projects.Dom.ClassType.Struct;
 
257
                                newType.ClassType = ClassType.Struct;
112
258
                                
113
 
                                LocationDescriptor location = LocationStorage.Get (s);
 
259
                                var location = LocationsBag.GetMemberLocation (s);
114
260
                                AddModifiers (newType, location);
115
 
                                newType.AddChild (new CSharpTokenNode (Convert (location[0]), "struct".Length), TypeDeclaration.TypeKeyword);
116
 
                                newType.AddChild (new Identifier (s.Name, Convert (location[1])), AbstractNode.Roles.Identifier);
 
261
                                if (location != null)
 
262
                                        newType.AddChild (new CSharpTokenNode (Convert (location[0]), "struct".Length), TypeDeclaration.Roles.Keyword);
 
263
                                newType.AddChild (CreateIdentifier (s.Basename, Convert (s.MemberName.Location)), AstNode.Roles.Identifier);
117
264
                                if (s.MemberName.TypeArguments != null)  {
118
 
                                        LocationDescriptor typeArgLocation = LocationStorage.Get (s.MemberName);
119
 
                                        newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), MemberReferenceExpression.Roles.LChevron);
120
 
                                        AddTypeArguments (newType, typeArgLocation, s.MemberName.TypeArguments);
121
 
                                        newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), MemberReferenceExpression.Roles.RChevron);
 
265
                                        var typeArgLocation = LocationsBag.GetLocations (s.MemberName);
 
266
                                        if (typeArgLocation != null)
 
267
                                                newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), TypeDeclaration.Roles.LChevron);
 
268
                                        AddTypeParameters (newType, typeArgLocation, s.MemberName.TypeArguments);
 
269
                                        if (typeArgLocation != null)
 
270
                                                newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), TypeDeclaration.Roles.RChevron);
122
271
                                        AddConstraints (newType, s);
123
272
                                }
124
 
                                
125
 
                                newType.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AbstractCSharpNode.Roles.LBrace);
 
273
                                if (location != null && location.Count > 1)
 
274
                                        newType.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AstNode.Roles.LBrace);
126
275
                                typeStack.Push (newType);
127
276
                                base.Visit (s);
128
 
                                newType.AddChild (new CSharpTokenNode  (Convert (location[3]), 1), AbstractCSharpNode.Roles.RBrace);
 
277
                                if (location != null && location.Count > 2)
 
278
                                        newType.AddChild (new CSharpTokenNode  (Convert (location[2]), 1), AstNode.Roles.RBrace);
129
279
                                typeStack.Pop ();
130
280
                                AddType (newType);
131
281
                        }
133
283
                        public override void Visit (Interface i)
134
284
                        {
135
285
                                TypeDeclaration newType = new TypeDeclaration ();
136
 
                                newType.ClassType = MonoDevelop.Projects.Dom.ClassType.Interface;
 
286
                                newType.ClassType = ClassType.Interface;
137
287
                                
138
 
                                LocationDescriptor location = LocationStorage.Get (i);
 
288
                                var location = LocationsBag.GetMemberLocation (i);
139
289
                                AddModifiers (newType, location);
140
 
                                newType.AddChild (new CSharpTokenNode (Convert (location[0]), "interface".Length), TypeDeclaration.TypeKeyword);
141
 
                                newType.AddChild (new Identifier (i.Name, Convert (location[1])), AbstractNode.Roles.Identifier);
 
290
                                if (location != null)
 
291
                                        newType.AddChild (new CSharpTokenNode (Convert (location[0]), "interface".Length), TypeDeclaration.Roles.Keyword);
 
292
                                newType.AddChild (CreateIdentifier (i.Basename, Convert (i.MemberName.Location)), AstNode.Roles.Identifier);
142
293
                                if (i.MemberName.TypeArguments != null)  {
143
 
                                        LocationDescriptor typeArgLocation = LocationStorage.Get (i.MemberName);
144
 
                                        newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), MemberReferenceExpression.Roles.LChevron);
145
 
                                        AddTypeArguments (newType, typeArgLocation, i.MemberName.TypeArguments);
146
 
                                        newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), MemberReferenceExpression.Roles.RChevron);
 
294
                                        var typeArgLocation = LocationsBag.GetLocations (i.MemberName);
 
295
                                        if (typeArgLocation != null)
 
296
                                                newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), MemberReferenceExpression.Roles.LChevron);
 
297
                                        AddTypeParameters (newType, typeArgLocation, i.MemberName.TypeArguments);
 
298
                                        if (typeArgLocation != null)
 
299
                                                newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), MemberReferenceExpression.Roles.RChevron);
147
300
                                        AddConstraints (newType, i);
148
301
                                }
149
 
                                
150
 
                                newType.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AbstractCSharpNode.Roles.LBrace);
 
302
                                if (location != null && location.Count > 1)
 
303
                                        newType.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AstNode.Roles.LBrace);
151
304
                                typeStack.Push (newType);
152
305
                                base.Visit (i);
153
 
                                newType.AddChild (new CSharpTokenNode  (Convert (location[3]), 1), AbstractCSharpNode.Roles.RBrace);
 
306
                                if (location != null && location.Count > 2)
 
307
                                        newType.AddChild (new CSharpTokenNode  (Convert (location[2]), 1), AstNode.Roles.RBrace);
154
308
                                typeStack.Pop ();
155
309
                                AddType (newType);
156
310
                        }
158
312
                        public override void Visit (Mono.CSharp.Delegate d)
159
313
                        {
160
314
                                DelegateDeclaration newDelegate = new DelegateDeclaration ();
161
 
                                LocationDescriptor location = LocationStorage.Get (d);
 
315
                                var location = LocationsBag.GetMemberLocation (d);
162
316
                                
163
317
                                AddModifiers (newDelegate, location);
164
 
                                
165
 
                                newDelegate.AddChild (new CSharpTokenNode (Convert (location[0]), "delegate".Length), TypeDeclaration.TypeKeyword);
166
 
                                newDelegate.AddChild ((INode)d.ReturnType.Accept (this), AbstractNode.Roles.ReturnType);
167
 
                                newDelegate.AddChild (new Identifier (d.Name, Convert (location[1])), AbstractNode.Roles.Identifier);
 
318
                                if (location != null)
 
319
                                        newDelegate.AddChild (new CSharpTokenNode (Convert (location[0]), "delegate".Length), TypeDeclaration.Roles.Keyword);
 
320
                                newDelegate.AddChild (ConvertToType (d.ReturnType), AstNode.Roles.Type);
 
321
                                newDelegate.AddChild (CreateIdentifier (d.Basename, Convert (d.MemberName.Location)), AstNode.Roles.Identifier);
168
322
                                if (d.MemberName.TypeArguments != null)  {
169
 
                                        LocationDescriptor typeArgLocation = LocationStorage.Get (d.MemberName);
170
 
                                        newDelegate.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), MemberReferenceExpression.Roles.LChevron);
171
 
                                        AddTypeArguments (newDelegate, typeArgLocation, d.MemberName.TypeArguments);
172
 
                                        newDelegate.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), MemberReferenceExpression.Roles.RChevron);
 
323
                                        var typeArgLocation = LocationsBag.GetLocations (d.MemberName);
 
324
                                        if (typeArgLocation != null)
 
325
                                                newDelegate.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), TypeDeclaration.Roles.LChevron);
 
326
                                        AddTypeParameters (newDelegate, typeArgLocation, d.MemberName.TypeArguments);
 
327
                                        if (typeArgLocation != null)
 
328
                                                newDelegate.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), TypeDeclaration.Roles.RChevron);
173
329
                                        AddConstraints (newDelegate, d);
174
330
                                }
175
 
                                
176
 
                                newDelegate.AddChild (new CSharpTokenNode (Convert (location[2]), 1), DelegateDeclaration.Roles.LPar);
177
 
                                newDelegate.AddChild (new CSharpTokenNode (Convert (location[3]), 1), DelegateDeclaration.Roles.RPar);
178
 
                                newDelegate.AddChild (new CSharpTokenNode (Convert (location[4]), 1), DelegateDeclaration.Roles.Semicolon);
179
 
                                
 
331
                                if (location != null)
 
332
                                        newDelegate.AddChild (new CSharpTokenNode (Convert (location[1]), 1), DelegateDeclaration.Roles.LPar);
 
333
                                AddParameter (newDelegate, d.Parameters);
 
334
                                
 
335
                                if (location != null) {
 
336
                                        newDelegate.AddChild (new CSharpTokenNode (Convert (location[2]), 1), DelegateDeclaration.Roles.RPar);
 
337
                                        newDelegate.AddChild (new CSharpTokenNode (Convert (location[3]), 1), DelegateDeclaration.Roles.Semicolon);
 
338
                                }
180
339
                                AddType (newDelegate);
181
340
                        }
182
341
                        
183
 
                        void AddType (INode child)
 
342
                        void AddType (AttributedNode child)
184
343
                        {
185
344
                                if (typeStack.Count > 0) {
186
 
                                        typeStack.Peek ().AddChild (child);
187
 
                                } else {
188
 
                                        unit.AddChild (child);
 
345
                                        typeStack.Peek ().AddChild (child, TypeDeclaration.MemberRole);
 
346
                                } else {
 
347
                                        AddToNamespace (child);
 
348
                                }
 
349
                        }
 
350
                        
 
351
                        void AddToNamespace (AstNode child)
 
352
                        {
 
353
                                if (namespaceStack.Count > 0) {
 
354
                                        namespaceStack.Peek ().AddChild (child, NamespaceDeclaration.MemberRole);
 
355
                                } else {
 
356
                                        unit.AddChild (child, MonoDevelop.CSharp.Ast.CompilationUnit.MemberRole);
189
357
                                }
190
358
                        }
191
359
                        
192
360
                        public override void Visit (Mono.CSharp.Enum e)
193
361
                        {
194
362
                                TypeDeclaration newType = new TypeDeclaration ();
195
 
                                newType.ClassType = MonoDevelop.Projects.Dom.ClassType.Enum;
196
 
                                LocationDescriptor location = LocationStorage.Get (e);
 
363
                                newType.ClassType = ClassType.Enum;
 
364
                                var location = LocationsBag.GetMemberLocation (e);
197
365
                                
198
366
                                AddModifiers (newType, location);
199
 
                                newType.AddChild (new CSharpTokenNode (Convert (location[0]), "enum".Length), TypeDeclaration.TypeKeyword);
200
 
                                newType.AddChild (new Identifier (e.Name, Convert (location[1])), AbstractNode.Roles.Identifier);
201
 
                                
202
 
                                newType.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AbstractCSharpNode.Roles.LBrace);
 
367
                                if (location != null)
 
368
                                        newType.AddChild (new CSharpTokenNode (Convert (location[0]), "enum".Length), TypeDeclaration.Roles.Keyword);
 
369
                                newType.AddChild (CreateIdentifier (e.Basename, Convert (e.MemberName.Location)), AstNode.Roles.Identifier);
 
370
                                if (location != null && location.Count > 1)
 
371
                                        newType.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AstNode.Roles.LBrace);
203
372
                                typeStack.Push (newType);
204
373
                                base.Visit (e);
205
 
                                newType.AddChild (new CSharpTokenNode  (Convert (location[3]), 1), AbstractCSharpNode.Roles.RBrace);
 
374
                                if (location != null && location.Count > 2)
 
375
                                        newType.AddChild (new CSharpTokenNode  (Convert (location[2]), 1), AstNode.Roles.RBrace);
206
376
                                typeStack.Pop ();
207
377
                                AddType (newType);
208
378
                        }
209
379
                        
210
380
                        public override void Visit (EnumMember em)
211
381
                        {
212
 
                                FieldDeclaration newField = new FieldDeclaration ();
 
382
                                EnumMemberDeclaration newField = new EnumMemberDeclaration ();
213
383
                                VariableInitializer variable = new VariableInitializer ();
214
384
                                
215
 
                                variable.AddChild (new Identifier (em.Name, Convert (em.Location)), AbstractNode.Roles.Identifier);
 
385
                                variable.AddChild (CreateIdentifier (em.Name, Convert (em.Location)), AstNode.Roles.Identifier);
216
386
                                
217
387
                                if (em.Initializer != null) {
218
 
                                        INode initializer = (INode)Visit (em.Initializer);
219
 
                                        if (initializer != null)
220
 
                                                variable.AddChild (initializer, AbstractNode.Roles.Initializer);
 
388
                                        variable.AddChild ((MonoDevelop.CSharp.Ast.Expression)em.Initializer.Accept (this), VariableInitializer.Roles.Expression);
221
389
                                }
222
390
                                
223
 
                                newField.AddChild (variable, AbstractNode.Roles.Initializer);
224
 
                                typeStack.Peek ().AddChild (newField, TypeDeclaration.Roles.Member);
225
 
                        }
226
 
                        
227
 
                        public override object Visit (EnumInitializer initializer)
228
 
                        {
229
 
                                return initializer.Expr != null ? initializer.Expr.Accept (this) : null;
 
391
                                newField.AddChild (variable, AstNode.Roles.Variable);
 
392
                                typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
230
393
                        }
231
394
                        #endregion
232
395
                        
233
396
                        #region Type members
 
397
                        
 
398
                        
234
399
                        public override void Visit (FixedField f)
235
400
                        {
236
 
                                LocationDescriptor location = LocationStorage.Get (f);
237
 
                                
238
 
                                FieldDeclaration newField;
239
 
                                
240
 
                                DomLocation semicolonLocation = Convert (location[0]);
241
 
                                if (!visitedFields.TryGetValue (semicolonLocation, out newField)) {
242
 
                                        newField = new FieldDeclaration ();
243
 
                                        
244
 
                                        newField.AddChild (new CSharpTokenNode (Convert (location[1]), "fixed".Length), FieldDeclaration.Roles.Keyword);
245
 
                                        newField.AddChild ((INode)f.TypeName.Accept (this), FieldDeclaration.Roles.ReturnType);
246
 
                                        newField.AddChild (new CSharpTokenNode (semicolonLocation, 1), FieldDeclaration.Roles.Semicolon);
247
 
                                        
248
 
                                        typeStack.Peek ().AddChild (newField, TypeDeclaration.Roles.Member);
249
 
                                        
250
 
                                        visitedFields[semicolonLocation] = newField;
251
 
                                } else {
252
 
                                        newField.InsertChildBefore (newField.Semicolon, new CSharpTokenNode (Convert (location.LocationList [newField.Variables.Count () - 1]), 1), FieldDeclaration.Roles.Comma);
253
 
                                }
 
401
                                var location = LocationsBag.GetMemberLocation (f);
 
402
                                
 
403
                                FieldDeclaration newField = new FieldDeclaration ();
 
404
                                
 
405
                                AddModifiers (newField, location);
 
406
                                if (location != null)
 
407
                                        newField.AddChild (new CSharpTokenNode (Convert (location[0]), "fixed".Length), FieldDeclaration.Roles.Keyword);
 
408
                                newField.AddChild (ConvertToType (f.TypeName), FieldDeclaration.Roles.Type);
254
409
                                
255
410
                                VariableInitializer variable = new VariableInitializer ();
256
 
                                variable.AddChild (new Identifier (f.MemberName.Name, Convert (f.MemberName.Location)), AbstractNode.Roles.Identifier);
257
 
                                newField.InsertChildBefore (newField.Semicolon, variable, AbstractNode.Roles.Initializer);
 
411
                                variable.AddChild (CreateIdentifier (f.MemberName.Name, Convert (f.MemberName.Location)), FieldDeclaration.Roles.Identifier);
 
412
                                if (!f.Initializer.IsNull) {
 
413
                                        variable.AddChild ((MonoDevelop.CSharp.Ast.Expression)f.Initializer.Accept (this), FieldDeclaration.Roles.Expression);
 
414
                                }
 
415
                                
 
416
                                newField.AddChild (variable, FieldDeclaration.Roles.Variable);
 
417
                                if (f.Declarators != null) {
 
418
                                        foreach (var decl in f.Declarators) {
 
419
                                                var declLoc = LocationsBag.GetLocations (decl);
 
420
                                                if (declLoc != null)
 
421
                                                        newField.AddChild (new CSharpTokenNode (Convert (declLoc[0]), 1), FieldDeclaration.Roles.Comma);
 
422
                                                
 
423
                                                variable = new VariableInitializer ();
 
424
                                                variable.AddChild (CreateIdentifier (decl.Name.Value, Convert (decl.Name.Location)), FieldDeclaration.Roles.Identifier);
 
425
                                                if (!decl.Initializer.IsNull) {
 
426
                                                        variable.AddChild ((MonoDevelop.CSharp.Ast.Expression)decl.Initializer.Accept (this), FieldDeclaration.Roles.Expression);
 
427
                                                }
 
428
                                                newField.AddChild (variable, FieldDeclaration.Roles.Variable);
 
429
                                        }
 
430
                                }
 
431
                                if (location != null)
 
432
                                        newField.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FieldDeclaration.Roles.Semicolon);
 
433
                                typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
 
434
                                
258
435
                        }
259
 
                        
260
 
                        Dictionary<DomLocation, FieldDeclaration> visitedFields = new Dictionary<DomLocation, FieldDeclaration> ();
 
436
 
261
437
                        public override void Visit (Field f)
262
438
                        {
263
 
                                LocationDescriptor location = LocationStorage.Get (f);
264
 
                                
265
 
                                FieldDeclaration newField;
266
 
                                
267
 
                                DomLocation semicolonLocation = Convert (location[0]);
268
 
                                if (!visitedFields.TryGetValue (semicolonLocation, out newField)) {
269
 
                                        newField = new FieldDeclaration ();
270
 
                                        newField.AddChild ((INode)f.TypeName.Accept (this), FieldDeclaration.Roles.ReturnType);
271
 
                                        newField.AddChild (new CSharpTokenNode (semicolonLocation, 1), FieldDeclaration.Roles.Semicolon);
272
 
                                        
273
 
                                        typeStack.Peek ().AddChild (newField, TypeDeclaration.Roles.Member);
274
 
                                        
275
 
                                        visitedFields[semicolonLocation] = newField;
276
 
                                } else {
277
 
                                        newField.InsertChildBefore (newField.Semicolon, new CSharpTokenNode (Convert (location.LocationList [newField.Variables.Count () - 1]), 1), FieldDeclaration.Roles.Comma);
278
 
                                }
279
 
                                
280
 
                                VariableInitializer variable = new VariableInitializer ();
281
 
                                variable.AddChild (new Identifier (f.MemberName.Name, Convert (f.MemberName.Location)), AbstractNode.Roles.Identifier);
282
 
                                newField.InsertChildBefore (newField.Semicolon, variable, AbstractNode.Roles.Initializer);
 
439
                                var location = LocationsBag.GetMemberLocation (f);
 
440
                                
 
441
                                FieldDeclaration newField = new FieldDeclaration ();
 
442
                                
 
443
                                AddModifiers (newField, location);
 
444
                                newField.AddChild (ConvertToType (f.TypeName), FieldDeclaration.Roles.Type);
 
445
                                
 
446
                                VariableInitializer variable = new VariableInitializer ();
 
447
                                variable.AddChild (CreateIdentifier (f.MemberName.Name, Convert (f.MemberName.Location)), FieldDeclaration.Roles.Identifier);
 
448
                                
 
449
                                if (f.Initializer != null) {
 
450
                                        if (location != null)
 
451
                                                variable.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FieldDeclaration.Roles.Assign);
 
452
                                        variable.AddChild ((MonoDevelop.CSharp.Ast.Expression)f.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 
453
                                }
 
454
                                newField.AddChild (variable, FieldDeclaration.Roles.Variable);
 
455
                                if (f.Declarators != null) {
 
456
                                        foreach (var decl in f.Declarators) {
 
457
                                                var declLoc = LocationsBag.GetLocations (decl);
 
458
                                                if (declLoc != null)
 
459
                                                        newField.AddChild (new CSharpTokenNode (Convert (declLoc[0]), 1), FieldDeclaration.Roles.Comma);
 
460
                                                
 
461
                                                variable = new VariableInitializer ();
 
462
                                                variable.AddChild (CreateIdentifier (decl.Name.Value, Convert (decl.Name.Location)), VariableInitializer.Roles.Identifier);
 
463
                                                if (decl.Initializer != null) {
 
464
                                                        variable.AddChild (new CSharpTokenNode (Convert (decl.Initializer.Location), 1), FieldDeclaration.Roles.Assign);
 
465
                                                        variable.AddChild ((MonoDevelop.CSharp.Ast.Expression)decl.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 
466
                                                }
 
467
                                                newField.AddChild (variable, FieldDeclaration.Roles.Variable);
 
468
                                        }
 
469
                                }
 
470
                                if (location != null)
 
471
                                        newField.AddChild (new CSharpTokenNode (Convert (location[location.Count - 1]), 1), FieldDeclaration.Roles.Semicolon);
 
472
 
 
473
                                typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
 
474
                        }
 
475
                        
 
476
                        public override void Visit (Const f)
 
477
                        {
 
478
                                var location = LocationsBag.GetMemberLocation (f);
 
479
                                
 
480
                                FieldDeclaration newField = new FieldDeclaration ();
 
481
                                
 
482
                                AddModifiers (newField, location);
 
483
                                if (location != null)
 
484
                                        newField.AddChild (new CSharpTokenNode (Convert (location[0]), "const".Length), FieldDeclaration.Roles.Keyword);
 
485
                                newField.AddChild (ConvertToType (f.TypeName), FieldDeclaration.Roles.Type);
 
486
                                
 
487
                                VariableInitializer variable = new VariableInitializer ();
 
488
                                variable.AddChild (CreateIdentifier (f.MemberName.Name, Convert (f.MemberName.Location)), VariableInitializer.Roles.Identifier);
 
489
                                
 
490
                                if (f.Initializer != null) {
 
491
                                        variable.AddChild (new CSharpTokenNode (Convert (f.Initializer.Location), 1), VariableInitializer.Roles.Assign);
 
492
                                        variable.AddChild ((MonoDevelop.CSharp.Ast.Expression)f.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 
493
                                }
 
494
                                newField.AddChild (variable, FieldDeclaration.Roles.Variable);
 
495
                                if (f.Declarators != null) {
 
496
                                        foreach (var decl in f.Declarators) {
 
497
                                                var declLoc = LocationsBag.GetLocations (decl);
 
498
                                                if (declLoc != null)
 
499
                                                        newField.AddChild (new CSharpTokenNode (Convert (declLoc[0]), 1), FieldDeclaration.Roles.Comma);
 
500
                                                
 
501
                                                variable = new VariableInitializer ();
 
502
                                                variable.AddChild (CreateIdentifier (decl.Name.Value, Convert (decl.Name.Location)), FieldDeclaration.Roles.Identifier);
 
503
                                                if (decl.Initializer != null) {
 
504
                                                        variable.AddChild (new CSharpTokenNode (Convert (decl.Initializer.Location), 1), FieldDeclaration.Roles.Assign);
 
505
                                                        variable.AddChild ((MonoDevelop.CSharp.Ast.Expression)decl.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 
506
                                                }
 
507
                                                newField.AddChild (variable, FieldDeclaration.Roles.Variable);
 
508
                                        }
 
509
                                }
 
510
                                if (location != null)
 
511
                                        newField.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FieldDeclaration.Roles.Semicolon);
 
512
                                
 
513
                                typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
 
514
 
 
515
                                
283
516
                        }
284
517
                        
285
518
                        public override void Visit (Operator o)
287
520
                                OperatorDeclaration newOperator = new OperatorDeclaration ();
288
521
                                newOperator.OperatorType = (OperatorType)o.OperatorType;
289
522
                                
290
 
                                LocationDescriptor location = LocationStorage.Get (o);
 
523
                                var location = LocationsBag.GetMemberLocation (o);
 
524
                                
291
525
                                AddModifiers (newOperator, location);
292
526
                                
293
 
                                newOperator.AddChild ((INode)o.TypeName.Accept (this), AbstractNode.Roles.ReturnType);
 
527
                                newOperator.AddChild (ConvertToType (o.TypeName), AstNode.Roles.Type);
294
528
                                
295
529
                                if (o.OperatorType == Operator.OpType.Implicit) {
296
 
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[3]), "implicit".Length), OperatorDeclaration.OperatorTypeRole);
297
 
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[2]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
 
530
                                        if (location != null) {
 
531
                                                newOperator.AddChild (new CSharpTokenNode (Convert (location[0]), "implicit".Length), OperatorDeclaration.OperatorTypeRole);
 
532
                                                newOperator.AddChild (new CSharpTokenNode (Convert (location[1]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
 
533
                                        }
298
534
                                } else if (o.OperatorType == Operator.OpType.Explicit) {
299
 
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[3]), "explicit".Length), OperatorDeclaration.OperatorTypeRole);
300
 
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[2]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
 
535
                                        if (location != null) {
 
536
                                                newOperator.AddChild (new CSharpTokenNode (Convert (location[0]), "explicit".Length), OperatorDeclaration.OperatorTypeRole);
 
537
                                                newOperator.AddChild (new CSharpTokenNode (Convert (location[1]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
 
538
                                        }
301
539
                                } else {
302
 
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[2]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
 
540
                                        if (location != null)
 
541
                                                newOperator.AddChild (new CSharpTokenNode (Convert (location[0]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
303
542
                                        
304
543
                                        int opLength = 1;
305
544
                                        switch (newOperator.OperatorType) {
306
 
                                        case OperatorType.LeftShift:
307
 
                                        case OperatorType.RightShift:
308
 
                                        case OperatorType.LessThanOrEqual:
309
 
                                        case OperatorType.GreaterThanOrEqual:
310
 
                                        case OperatorType.Equality:
311
 
                                        case OperatorType.Inequality:
 
545
                                                case OperatorType.LeftShift:
 
546
                                                case OperatorType.RightShift:
 
547
                                                case OperatorType.LessThanOrEqual:
 
548
                                                case OperatorType.GreaterThanOrEqual:
 
549
                                                case OperatorType.Equality:
 
550
                                                case OperatorType.Inequality:
312
551
//                                      case OperatorType.LogicalAnd:
313
552
//                                      case OperatorType.LogicalOr:
314
 
                                                opLength = 2;
315
 
                                                break;
316
 
                                        case OperatorType.True:
317
 
                                                opLength = "true".Length;
318
 
                                                break;
319
 
                                        case OperatorType.False:
320
 
                                                opLength = "false".Length;
321
 
                                                break;
 
553
                                                        opLength = 2;
 
554
                                                        break;
 
555
                                                case OperatorType.True:
 
556
                                                        opLength = "true".Length;
 
557
                                                        break;
 
558
                                                case OperatorType.False:
 
559
                                                        opLength = "false".Length;
 
560
                                                        break;
322
561
                                        }
323
 
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[3]), opLength), OperatorDeclaration.OperatorTypeRole);
 
562
                                        if (location != null)
 
563
                                                newOperator.AddChild (new CSharpTokenNode (Convert (location[1]), opLength), OperatorDeclaration.OperatorTypeRole);
324
564
                                }
325
 
                                
326
 
                                newOperator.AddChild (new CSharpTokenNode (Convert (location[0]), 1), OperatorDeclaration.Roles.LPar);
 
565
                                if (location != null)
 
566
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[2]), 1), OperatorDeclaration.Roles.LPar);
327
567
                                AddParameter (newOperator, o.ParameterInfo);
328
 
                                newOperator.AddChild (new CSharpTokenNode (Convert (location[1]), 1), OperatorDeclaration.Roles.RPar);
 
568
                                if (location != null)
 
569
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[3]), 1), OperatorDeclaration.Roles.RPar);
329
570
                                
330
571
                                if (o.Block != null)
331
 
                                        newOperator.AddChild ((INode)o.Block.Accept (this), OperatorDeclaration.Roles.Body);
 
572
                                        newOperator.AddChild ((BlockStatement)o.Block.Accept (this), OperatorDeclaration.Roles.Body);
332
573
                                
333
 
                                typeStack.Peek ().AddChild (newOperator, TypeDeclaration.Roles.Member);
 
574
                                typeStack.Peek ().AddChild (newOperator, TypeDeclaration.MemberRole);
334
575
                        }
335
576
                        
336
577
                        public override void Visit (Indexer indexer)
337
578
                        {
338
579
                                IndexerDeclaration newIndexer = new IndexerDeclaration ();
339
580
                                
340
 
                                LocationDescriptor location = LocationStorage.Get (indexer);
 
581
                                var location = LocationsBag.GetMemberLocation (indexer);
341
582
                                AddModifiers (newIndexer, location);
342
583
                                
343
 
                                newIndexer.AddChild ((INode)indexer.TypeName.Accept (this), AbstractNode.Roles.ReturnType);
344
 
                                
345
 
                                newIndexer.AddChild (new CSharpTokenNode (Convert (location[0]), 1), IndexerDeclaration.Roles.LBracket);
346
 
                                AddParameter (newIndexer, indexer.parameters);
347
 
                                newIndexer.AddChild (new CSharpTokenNode (Convert (location[1]), 1), IndexerDeclaration.Roles.RBracket);
348
 
                                
349
 
                                newIndexer.AddChild (new CSharpTokenNode (Convert (location[2]), 1), IndexerDeclaration.Roles.LBrace);
 
584
                                newIndexer.AddChild (ConvertToType (indexer.TypeName), AstNode.Roles.Type);
 
585
                                
 
586
                                if (location != null)
 
587
                                        newIndexer.AddChild (new CSharpTokenNode (Convert (location[0]), 1), IndexerDeclaration.Roles.LBracket);
 
588
                                AddParameter (newIndexer, indexer.ParameterInfo);
 
589
                                if (location != null)
 
590
                                        newIndexer.AddChild (new CSharpTokenNode (Convert (location[1]), 1), IndexerDeclaration.Roles.RBracket);
 
591
                                
 
592
                                if (location != null)
 
593
                                        newIndexer.AddChild (new CSharpTokenNode (Convert (location[2]), 1), IndexerDeclaration.Roles.LBrace);
350
594
                                if (indexer.Get != null) {
351
 
                                        MonoDevelop.CSharp.Dom.Accessor getAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
352
 
                                        LocationDescriptor getLocation = LocationStorage.Get (indexer.Get);
 
595
                                        Accessor getAccessor = new Accessor ();
 
596
                                        var getLocation = LocationsBag.GetMemberLocation (indexer.Get);
353
597
                                        AddModifiers (getAccessor, getLocation);
354
 
                                        getAccessor.AddChild (new CSharpTokenNode (Convert (getLocation[0]), "get".Length), PropertyDeclaration.Roles.Keyword);
355
 
                                        if (indexer.Get.Block != null)
356
 
                                                getAccessor.AddChild ((INode)indexer.Get.Block.Accept (this), MethodDeclaration.Roles.Body);
357
 
                                        newIndexer.AddChild (getAccessor, PropertyDeclaration.PropertyGetRole);
 
598
                                        if (getLocation != null)
 
599
                                                getAccessor.AddChild (new CSharpTokenNode (Convert (indexer.Get.Location), "get".Length), PropertyDeclaration.Roles.Keyword);
 
600
                                        if (indexer.Get.Block != null) {
 
601
                                                getAccessor.AddChild ((BlockStatement)indexer.Get.Block.Accept (this), MethodDeclaration.Roles.Body);
 
602
                                        } else {
 
603
                                                if (getLocation != null && getLocation.Count > 0)
 
604
                                                        newIndexer.AddChild (new CSharpTokenNode (Convert (getLocation[0]), 1), MethodDeclaration.Roles.Semicolon);
 
605
                                        }
 
606
                                        newIndexer.AddChild (getAccessor, PropertyDeclaration.GetterRole);
358
607
                                }
359
608
                                
360
609
                                if (indexer.Set != null) {
361
 
                                        MonoDevelop.CSharp.Dom.Accessor setAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
362
 
                                        LocationDescriptor setLocation = LocationStorage.Get (indexer.Set);
 
610
                                        Accessor setAccessor = new Accessor ();
 
611
                                        var setLocation = LocationsBag.GetMemberLocation (indexer.Set);
363
612
                                        AddModifiers (setAccessor, setLocation);
364
 
                                        setAccessor.AddChild (new CSharpTokenNode (Convert (setLocation[0]), "set".Length), PropertyDeclaration.Roles.Keyword);
 
613
                                        if (setLocation != null)
 
614
                                                setAccessor.AddChild (new CSharpTokenNode (Convert (indexer.Set.Location), "set".Length), PropertyDeclaration.Roles.Keyword);
365
615
                                        
366
 
                                        if (indexer.Set.Block != null)
367
 
                                                setAccessor.AddChild ((INode)indexer.Set.Block.Accept (this), MethodDeclaration.Roles.Body);
368
 
                                        newIndexer.AddChild (setAccessor, PropertyDeclaration.PropertySetRole);
 
616
                                        if (indexer.Set.Block != null) {
 
617
                                                setAccessor.AddChild ((BlockStatement)indexer.Set.Block.Accept (this), MethodDeclaration.Roles.Body);
 
618
                                        } else {
 
619
                                                if (setLocation != null && setLocation.Count > 0)
 
620
                                                        newIndexer.AddChild (new CSharpTokenNode (Convert (setLocation[0]), 1), MethodDeclaration.Roles.Semicolon);
 
621
                                        }
 
622
                                        newIndexer.AddChild (setAccessor, PropertyDeclaration.SetterRole);
369
623
                                }
370
624
                                
371
 
                                newIndexer.AddChild (new CSharpTokenNode (Convert (location[3]), 1), IndexerDeclaration.Roles.RBrace);
 
625
                                if (location != null)
 
626
                                        newIndexer.AddChild (new CSharpTokenNode (Convert (location[3]), 1), IndexerDeclaration.Roles.RBrace);
372
627
                                
373
 
                                typeStack.Peek ().AddChild (newIndexer, TypeDeclaration.Roles.Member);
 
628
                                typeStack.Peek ().AddChild (newIndexer, TypeDeclaration.MemberRole);
374
629
                        }
375
630
                        
376
631
                        public override void Visit (Method m)
377
632
                        {
378
633
                                MethodDeclaration newMethod = new MethodDeclaration ();
379
634
                                
380
 
                                LocationDescriptor location = LocationStorage.Get (m);
 
635
                                var location = LocationsBag.GetMemberLocation (m);
381
636
                                AddModifiers (newMethod, location);
382
637
                                
383
 
                                newMethod.AddChild ((INode)m.TypeName.Accept (this), AbstractNode.Roles.ReturnType);
384
 
                                newMethod.AddChild (new Identifier (m.Name, Convert (m.Location)), AbstractNode.Roles.Identifier);
 
638
                                newMethod.AddChild (ConvertToType (m.TypeName), AstNode.Roles.Type);
 
639
                                newMethod.AddChild (CreateIdentifier (m.Name, Convert (m.Location)), AstNode.Roles.Identifier);
385
640
                                
386
641
                                if (m.MemberName.TypeArguments != null)  {
387
 
                                        LocationDescriptor typeArgLocation = LocationStorage.Get (m.MemberName);
388
 
                                        newMethod.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), MemberReferenceExpression.Roles.LChevron);
389
 
                                        AddTypeArguments (newMethod, typeArgLocation, m.MemberName.TypeArguments);
390
 
                                        newMethod.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), MemberReferenceExpression.Roles.RChevron);
 
642
                                        var typeArgLocation = LocationsBag.GetLocations (m.MemberName);
 
643
                                        if (typeArgLocation != null)
 
644
                                                newMethod.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), MemberReferenceExpression.Roles.LChevron);
 
645
                                        AddTypeParameters (newMethod, typeArgLocation, m.MemberName.TypeArguments);
 
646
                                        if (typeArgLocation != null)
 
647
                                                newMethod.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), MemberReferenceExpression.Roles.RChevron);
391
648
                                        
392
649
                                        AddConstraints (newMethod, m.GenericMethod);
393
650
                                }
394
651
                                
395
 
                                newMethod.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LPar);
396
 
                                
 
652
                                if (location != null)
 
653
                                        newMethod.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LPar);
397
654
                                AddParameter (newMethod, m.ParameterInfo);
398
655
                                
399
 
                                newMethod.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RPar);
400
 
                                
401
 
                                if (m.Block != null)
402
 
                                        newMethod.AddChild ((INode)m.Block.Accept (this), MethodDeclaration.Roles.Body);
403
 
                                typeStack.Peek ().AddChild (newMethod, TypeDeclaration.Roles.Member);
 
656
                                if (location != null)
 
657
                                        newMethod.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RPar);
 
658
                                if (m.Block != null) {
 
659
                                        var bodyBlock = (BlockStatement)m.Block.Accept (this);
 
660
//                                      if (m.Block is ToplevelBlock) {
 
661
//                                              newMethod.AddChild (bodyBlock.FirstChild.NextSibling, MethodDeclaration.Roles.Body);
 
662
//                                      } else {
 
663
                                        newMethod.AddChild (bodyBlock, MethodDeclaration.Roles.Body);
 
664
//                                      }
 
665
                                }
 
666
                                typeStack.Peek ().AddChild (newMethod, TypeDeclaration.MemberRole);
404
667
                        }
405
668
                        
406
669
                        static Dictionary<Mono.CSharp.Modifiers, MonoDevelop.Projects.Dom.Modifiers> modifierTable = new Dictionary<Mono.CSharp.Modifiers, MonoDevelop.Projects.Dom.Modifiers> ();
 
670
                        static string[] keywordTable;
 
671
                        
407
672
                        static ConversionVisitor ()
408
673
                        {
409
 
                                modifierTable[Mono.CSharp.Modifiers.NEW] = MonoDevelop.Projects.Dom.Modifiers.New;
410
 
                                modifierTable[Mono.CSharp.Modifiers.PUBLIC] = MonoDevelop.Projects.Dom.Modifiers.Public;
411
 
                                modifierTable[Mono.CSharp.Modifiers.PROTECTED] = MonoDevelop.Projects.Dom.Modifiers.Protected;
412
 
                                modifierTable[Mono.CSharp.Modifiers.PRIVATE] = MonoDevelop.Projects.Dom.Modifiers.Private;
413
 
                                modifierTable[Mono.CSharp.Modifiers.INTERNAL] = MonoDevelop.Projects.Dom.Modifiers.Internal;
414
 
                                modifierTable[Mono.CSharp.Modifiers.ABSTRACT] = MonoDevelop.Projects.Dom.Modifiers.Abstract;
415
 
                                modifierTable[Mono.CSharp.Modifiers.VIRTUAL] = MonoDevelop.Projects.Dom.Modifiers.Virtual;
416
 
                                modifierTable[Mono.CSharp.Modifiers.SEALED] = MonoDevelop.Projects.Dom.Modifiers.Sealed;
417
 
                                modifierTable[Mono.CSharp.Modifiers.STATIC] = MonoDevelop.Projects.Dom.Modifiers.Static;
418
 
                                modifierTable[Mono.CSharp.Modifiers.OVERRIDE] = MonoDevelop.Projects.Dom.Modifiers.Override;
419
 
                                modifierTable[Mono.CSharp.Modifiers.READONLY] = MonoDevelop.Projects.Dom.Modifiers.Readonly;
420
 
//                              modifierTable[Mono.CSharp.Modifiers.] = MonoDevelop.Projects.Dom.Modifiers.Const;
421
 
                                modifierTable[Mono.CSharp.Modifiers.PARTIAL] = MonoDevelop.Projects.Dom.Modifiers.Partial;
422
 
                                modifierTable[Mono.CSharp.Modifiers.EXTERN] = MonoDevelop.Projects.Dom.Modifiers.Extern;
423
 
                                modifierTable[Mono.CSharp.Modifiers.VOLATILE] = MonoDevelop.Projects.Dom.Modifiers.Volatile;
424
 
                                modifierTable[Mono.CSharp.Modifiers.UNSAFE] = MonoDevelop.Projects.Dom.Modifiers.Unsafe;
425
 
                                modifierTable[Mono.CSharp.Modifiers.OVERRIDE] = MonoDevelop.Projects.Dom.Modifiers.Overloads;
 
674
                                modifierTable [Mono.CSharp.Modifiers.NEW] = MonoDevelop.Projects.Dom.Modifiers.New;
 
675
                                modifierTable [Mono.CSharp.Modifiers.PUBLIC] = MonoDevelop.Projects.Dom.Modifiers.Public;
 
676
                                modifierTable [Mono.CSharp.Modifiers.PROTECTED] = MonoDevelop.Projects.Dom.Modifiers.Protected;
 
677
                                modifierTable [Mono.CSharp.Modifiers.PRIVATE] = MonoDevelop.Projects.Dom.Modifiers.Private;
 
678
                                modifierTable [Mono.CSharp.Modifiers.INTERNAL] = MonoDevelop.Projects.Dom.Modifiers.Internal;
 
679
                                modifierTable [Mono.CSharp.Modifiers.ABSTRACT] = MonoDevelop.Projects.Dom.Modifiers.Abstract;
 
680
                                modifierTable [Mono.CSharp.Modifiers.VIRTUAL] = MonoDevelop.Projects.Dom.Modifiers.Virtual;
 
681
                                modifierTable [Mono.CSharp.Modifiers.SEALED] = MonoDevelop.Projects.Dom.Modifiers.Sealed;
 
682
                                modifierTable [Mono.CSharp.Modifiers.STATIC] = MonoDevelop.Projects.Dom.Modifiers.Static;
 
683
                                modifierTable [Mono.CSharp.Modifiers.OVERRIDE] = MonoDevelop.Projects.Dom.Modifiers.Override;
 
684
                                modifierTable [Mono.CSharp.Modifiers.READONLY] = MonoDevelop.Projects.Dom.Modifiers.Readonly;
 
685
                                //                              modifierTable[Mono.CSharp.Modifiers.] = Modifiers.Const;
 
686
                                modifierTable [Mono.CSharp.Modifiers.PARTIAL] = MonoDevelop.Projects.Dom.Modifiers.Partial;
 
687
                                modifierTable [Mono.CSharp.Modifiers.EXTERN] = MonoDevelop.Projects.Dom.Modifiers.Extern;
 
688
                                modifierTable [Mono.CSharp.Modifiers.VOLATILE] = MonoDevelop.Projects.Dom.Modifiers.Volatile;
 
689
                                modifierTable [Mono.CSharp.Modifiers.UNSAFE] = MonoDevelop.Projects.Dom.Modifiers.Unsafe;
 
690
                                
 
691
                                keywordTable = new string[255];
 
692
                                for (int i = 0; i< keywordTable.Length; i++) 
 
693
                                        keywordTable [i] = "unknown";
 
694
                                
 
695
                                keywordTable [(int)BuiltinTypeSpec.Type.Other] = "void";
 
696
                                keywordTable [(int)BuiltinTypeSpec.Type.String] = "string";
 
697
                                keywordTable [(int)BuiltinTypeSpec.Type.Int] = "int";
 
698
                                keywordTable [(int)BuiltinTypeSpec.Type.Object] = "object";
 
699
                                keywordTable [(int)BuiltinTypeSpec.Type.Float] = "float";
 
700
                                keywordTable [(int)BuiltinTypeSpec.Type.Double] = "double";
 
701
                                keywordTable [(int)BuiltinTypeSpec.Type.Long] = "long";
 
702
                                keywordTable [(int)BuiltinTypeSpec.Type.Byte] = "byte";
 
703
                                keywordTable [(int)BuiltinTypeSpec.Type.UInt] = "uint";
 
704
                                keywordTable [(int)BuiltinTypeSpec.Type.ULong] = "ulong";
 
705
                                keywordTable [(int)BuiltinTypeSpec.Type.Short] = "short";
 
706
                                keywordTable [(int)BuiltinTypeSpec.Type.UShort] = "ushort";
 
707
                                keywordTable [(int)BuiltinTypeSpec.Type.SByte] = "sbyte";
 
708
                                keywordTable [(int)BuiltinTypeSpec.Type.Decimal] = "decimal";
 
709
                                keywordTable [(int)BuiltinTypeSpec.Type.Char] = "char";
426
710
                        }
427
711
                        
428
 
                        void AddModifiers (AbstractNode parent, Mono.CSharp.LocationDescriptor location)
 
712
                        void AddModifiers (AttributedNode parent, LocationsBag.MemberLocations location)
429
713
                        {
430
 
                                if (location.Modifiers == null)
 
714
                                if (location == null || location.Modifiers == null)
431
715
                                        return;
432
716
                                foreach (var modifier in location.Modifiers) {
433
 
                                        parent.AddChild (new CSharpModifierToken (Convert (modifier.Item1), modifierTable[modifier.Item2]), AbstractNode.Roles.Modifier);
 
717
                                        parent.AddChild (new CSharpModifierToken (Convert (modifier.Item2), modifierTable[modifier.Item1]), AttributedNode.ModifierRole);
434
718
                                }
435
719
                        }
436
720
                        
438
722
                        {
439
723
                                PropertyDeclaration newProperty = new PropertyDeclaration ();
440
724
                                
441
 
                                LocationDescriptor location = LocationStorage.Get (p);
 
725
                                var location = LocationsBag.GetMemberLocation (p);
442
726
                                AddModifiers (newProperty, location);
443
 
                                
444
 
                                newProperty.AddChild ((INode)p.TypeName.Accept (this), AbstractNode.Roles.ReturnType);
445
 
                                newProperty.AddChild (new Identifier (p.MemberName.Name, Convert (p.MemberName.Location)), AbstractNode.Roles.Identifier);
446
 
                                newProperty.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LBrace);
 
727
                                newProperty.AddChild (ConvertToType (p.TypeName), AstNode.Roles.Type);
 
728
                                newProperty.AddChild (CreateIdentifier (p.MemberName.Name, Convert (p.MemberName.Location)), AstNode.Roles.Identifier);
 
729
                                if (location != null)
 
730
                                        newProperty.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LBrace);
447
731
                                
448
732
                                if (p.Get != null) {
449
 
                                        MonoDevelop.CSharp.Dom.Accessor getAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
450
 
                                        LocationDescriptor getLocation = LocationStorage.Get (p.Get);
 
733
                                        Accessor getAccessor = new Accessor ();
 
734
                                        var getLocation = LocationsBag.GetMemberLocation (p.Get);
451
735
                                        AddModifiers (getAccessor, getLocation);
452
 
                                        getAccessor.AddChild (new CSharpTokenNode (Convert (getLocation[0]), "get".Length), PropertyDeclaration.Roles.Keyword);
 
736
                                        getAccessor.AddChild (new CSharpTokenNode (Convert (p.Get.Location), "get".Length), PropertyDeclaration.Roles.Keyword);
453
737
                                        
454
 
                                        if (p.Get.Block != null)
455
 
                                                getAccessor.AddChild ((INode)p.Get.Block.Accept (this), MethodDeclaration.Roles.Body);
456
 
                                        newProperty.AddChild (getAccessor, PropertyDeclaration.PropertyGetRole);
 
738
                                        if (p.Get.Block != null) {
 
739
                                                getAccessor.AddChild ((BlockStatement)p.Get.Block.Accept (this), MethodDeclaration.Roles.Body);
 
740
                                        } else {
 
741
                                                if (getLocation != null && getLocation.Count > 0)
 
742
                                                        newProperty.AddChild (new CSharpTokenNode (Convert (getLocation[0]), 1), MethodDeclaration.Roles.Semicolon);
 
743
                                        }
 
744
                                        newProperty.AddChild (getAccessor, PropertyDeclaration.GetterRole);
457
745
                                }
458
746
                                
459
747
                                if (p.Set != null) {
460
 
                                        MonoDevelop.CSharp.Dom.Accessor setAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
461
 
                                        LocationDescriptor setLocation = LocationStorage.Get (p.Set);
 
748
                                        Accessor setAccessor = new Accessor ();
 
749
                                        var setLocation = LocationsBag.GetMemberLocation (p.Set);
462
750
                                        AddModifiers (setAccessor, setLocation);
463
 
                                        setAccessor.AddChild (new CSharpTokenNode (Convert (setLocation[0]), "set".Length), PropertyDeclaration.Roles.Keyword);
 
751
                                        setAccessor.AddChild (new CSharpTokenNode (Convert (p.Set.Location), "set".Length), PropertyDeclaration.Roles.Keyword);
464
752
                                        
465
 
                                        if (p.Set.Block != null)
466
 
                                                setAccessor.AddChild ((INode)p.Set.Block.Accept (this), MethodDeclaration.Roles.Body);
467
 
                                        newProperty.AddChild (setAccessor, PropertyDeclaration.PropertySetRole);
 
753
                                        if (p.Set.Block != null) {
 
754
                                                setAccessor.AddChild ((BlockStatement)p.Set.Block.Accept (this), MethodDeclaration.Roles.Body);
 
755
                                        } else {
 
756
                                                if (setLocation != null && setLocation.Count > 0)
 
757
                                                        newProperty.AddChild (new CSharpTokenNode (Convert (setLocation[0]), 1), MethodDeclaration.Roles.Semicolon);
 
758
                                        }
 
759
                                        newProperty.AddChild (setAccessor, PropertyDeclaration.SetterRole);
468
760
                                }
469
 
                                newProperty.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RBrace);
 
761
                                if (location != null)
 
762
                                        newProperty.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RBrace);
470
763
                                
471
 
                                typeStack.Peek ().AddChild (newProperty, TypeDeclaration.Roles.Member);
 
764
                                typeStack.Peek ().AddChild (newProperty, TypeDeclaration.MemberRole);
472
765
                        }
473
766
                        
474
767
                        public override void Visit (Constructor c)
475
768
                        {
476
769
                                ConstructorDeclaration newConstructor = new ConstructorDeclaration ();
477
 
                                LocationDescriptor location = LocationStorage.Get (c);
 
770
                                var location = LocationsBag.GetMemberLocation (c);
478
771
                                AddModifiers (newConstructor, location);
479
 
                                newConstructor.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LPar);
480
 
                                newConstructor.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RPar);
 
772
                                newConstructor.AddChild (CreateIdentifier (c.MemberName.Name, Convert (c.MemberName.Location)), AstNode.Roles.Identifier);
 
773
                                if (location != null)
 
774
                                        newConstructor.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LPar);
 
775
                                
 
776
                                AddParameter (newConstructor, c.ParameterInfo);
 
777
                                if (location != null)
 
778
                                        newConstructor.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RPar);
481
779
                                
482
780
                                if (c.Block != null)
483
 
                                        newConstructor.AddChild ((INode)c.Block.Accept (this), ConstructorDeclaration.Roles.Body);
 
781
                                        newConstructor.AddChild ((BlockStatement)c.Block.Accept (this), ConstructorDeclaration.Roles.Body);
484
782
                                
485
 
                                typeStack.Peek ().AddChild (newConstructor, TypeDeclaration.Roles.Member);
 
783
                                typeStack.Peek ().AddChild (newConstructor, TypeDeclaration.MemberRole);
486
784
                        }
487
785
                        
488
786
                        public override void Visit (Destructor d)
489
787
                        {
490
788
                                DestructorDeclaration newDestructor = new DestructorDeclaration ();
491
 
                                LocationDescriptor location = LocationStorage.Get (d);
 
789
                                var location = LocationsBag.GetMemberLocation (d);
492
790
                                AddModifiers (newDestructor, location);
493
 
                                newDestructor.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LPar);
494
 
                                newDestructor.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RPar);
 
791
                                if (location != null)
 
792
                                        newDestructor.AddChild (new CSharpTokenNode (Convert (location[0]), 1), DestructorDeclaration.TildeRole);
 
793
                                newDestructor.AddChild (CreateIdentifier (d.MemberName.Name, Convert (d.MemberName.Location)), AstNode.Roles.Identifier);
 
794
                                
 
795
                                if (location != null) {
 
796
                                        newDestructor.AddChild (new CSharpTokenNode (Convert (location[1]), 1), DestructorDeclaration.Roles.LPar);
 
797
                                        newDestructor.AddChild (new CSharpTokenNode (Convert (location[2]), 1), DestructorDeclaration.Roles.RPar);
 
798
                                }
495
799
                                
496
800
                                if (d.Block != null)
497
 
                                        newDestructor.AddChild ((INode)d.Block.Accept (this), DestructorDeclaration.Roles.Body);
 
801
                                        newDestructor.AddChild ((BlockStatement)d.Block.Accept (this), DestructorDeclaration.Roles.Body);
498
802
                                
499
 
                                typeStack.Peek ().AddChild (newDestructor, TypeDeclaration.Roles.Member);
 
803
                                typeStack.Peek ().AddChild (newDestructor, TypeDeclaration.MemberRole);
500
804
                        }
501
805
                        
502
806
                        public override void Visit (EventField e)
503
807
                        {
504
808
                                EventDeclaration newEvent = new EventDeclaration ();
505
809
                                
506
 
                                LocationDescriptor location = LocationStorage.Get (e);
 
810
                                var location = LocationsBag.GetMemberLocation (e);
507
811
                                AddModifiers (newEvent, location);
508
812
                                
509
 
                                newEvent.AddChild (new CSharpTokenNode (Convert (location[0]), "event".Length), EventDeclaration.Roles.Keyword);
510
 
                                newEvent.AddChild ((INode)e.TypeName.Accept (this), AbstractNode.Roles.ReturnType);
511
 
                                newEvent.AddChild (new Identifier (e.MemberName.Name, Convert (e.MemberName.Location)), EventDeclaration.Roles.Identifier);
512
 
                                newEvent.AddChild (new CSharpTokenNode (Convert (location[1]), ";".Length), EventDeclaration.Roles.Semicolon);
 
813
                                if (location != null)
 
814
                                        newEvent.AddChild (new CSharpTokenNode (Convert (location[0]), "event".Length), EventDeclaration.Roles.Keyword);
 
815
                                newEvent.AddChild (ConvertToType (e.TypeName), AstNode.Roles.Type);
 
816
                                newEvent.AddChild (CreateIdentifier (e.MemberName.Name, Convert (e.MemberName.Location)), EventDeclaration.Roles.Identifier);
 
817
                                if (location != null)
 
818
                                        newEvent.AddChild (new CSharpTokenNode (Convert (location[1]), ";".Length), EventDeclaration.Roles.Semicolon);
513
819
                                
514
 
                                typeStack.Peek ().AddChild (newEvent, TypeDeclaration.Roles.Member);
 
820
                                typeStack.Peek ().AddChild (newEvent, TypeDeclaration.MemberRole);
515
821
                        }
516
822
                        
517
823
                        public override void Visit (EventProperty ep)
518
824
                        {
519
 
                                EventDeclaration newEvent = new EventDeclaration ();
 
825
                                CustomEventDeclaration newEvent = new CustomEventDeclaration ();
520
826
                                
521
 
                                LocationDescriptor location = LocationStorage.Get (ep);
 
827
                                var location = LocationsBag.GetMemberLocation (ep);
522
828
                                AddModifiers (newEvent, location);
523
829
                                
524
 
                                newEvent.AddChild (new CSharpTokenNode (Convert (location[0]), "event".Length), EventDeclaration.Roles.Keyword);
525
 
                                newEvent.AddChild ((INode)ep.TypeName.Accept (this), EventDeclaration.Roles.ReturnType);
526
 
                                newEvent.AddChild (new Identifier (ep.MemberName.Name, Convert (ep.MemberName.Location)), EventDeclaration.Roles.Identifier);
527
 
                                newEvent.AddChild (new CSharpTokenNode (Convert (location[1]), 1), EventDeclaration.Roles.LBrace);
 
830
                                if (location != null)
 
831
                                        newEvent.AddChild (new CSharpTokenNode (Convert (location[0]), "event".Length), CustomEventDeclaration.Roles.Keyword);
 
832
                                newEvent.AddChild (ConvertToType (ep.TypeName), CustomEventDeclaration.Roles.Type);
 
833
                                newEvent.AddChild (CreateIdentifier (ep.MemberName.Name, Convert (ep.MemberName.Location)), CustomEventDeclaration.Roles.Identifier);
 
834
                                if (location != null && location.Count >= 2)
 
835
                                        newEvent.AddChild (new CSharpTokenNode (Convert (location[1]), 1), CustomEventDeclaration.Roles.LBrace);
528
836
                                
529
837
                                if (ep.Add != null) {
530
 
                                        MonoDevelop.CSharp.Dom.Accessor addAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
531
 
                                        LocationDescriptor addLocation = LocationStorage.Get (ep.Add);
 
838
                                        Accessor addAccessor = new Accessor ();
 
839
                                        var addLocation = LocationsBag.GetMemberLocation (ep.Add);
532
840
                                        AddModifiers (addAccessor, addLocation);
533
 
                                        addAccessor.AddChild (new CSharpTokenNode (Convert (addLocation[0]), "add".Length), EventDeclaration.Roles.Keyword);
 
841
                                        addAccessor.AddChild (new CSharpTokenNode (Convert (ep.Add.Location), "add".Length), CustomEventDeclaration.Roles.Keyword);
534
842
                                        if (ep.Add.Block != null)
535
 
                                                addAccessor.AddChild ((INode)ep.Add.Block.Accept (this), EventDeclaration.Roles.Body);
536
 
                                        newEvent.AddChild (addAccessor, EventDeclaration.EventAddRole);
 
843
                                                addAccessor.AddChild ((BlockStatement)ep.Add.Block.Accept (this), CustomEventDeclaration.Roles.Body);
 
844
                                        newEvent.AddChild (addAccessor, CustomEventDeclaration.AddAccessorRole);
537
845
                                }
538
846
                                
539
847
                                if (ep.Remove != null) {
540
 
                                        MonoDevelop.CSharp.Dom.Accessor removeAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
541
 
                                        LocationDescriptor removeLocation = LocationStorage.Get (ep.Remove);
 
848
                                        Accessor removeAccessor = new Accessor ();
 
849
                                        var removeLocation = LocationsBag.GetMemberLocation (ep.Remove);
542
850
                                        AddModifiers (removeAccessor, removeLocation);
543
 
                                        removeAccessor.AddChild (new CSharpTokenNode (Convert (removeLocation[0]), "remove".Length), EventDeclaration.Roles.Keyword);
 
851
                                        removeAccessor.AddChild (new CSharpTokenNode (Convert (ep.Remove.Location), "remove".Length), CustomEventDeclaration.Roles.Keyword);
544
852
                                        
545
853
                                        if (ep.Remove.Block != null)
546
 
                                                removeAccessor.AddChild ((INode)ep.Remove.Block.Accept (this), EventDeclaration.Roles.Body);
547
 
                                        newEvent.AddChild (removeAccessor, EventDeclaration.EventRemoveRole);
 
854
                                                removeAccessor.AddChild ((BlockStatement)ep.Remove.Block.Accept (this), CustomEventDeclaration.Roles.Body);
 
855
                                        newEvent.AddChild (removeAccessor, CustomEventDeclaration.RemoveAccessorRole);
548
856
                                }
549
 
                                newEvent.AddChild (new CSharpTokenNode (Convert (location[2]), 1), EventDeclaration.Roles.RBrace);
 
857
                                if (location != null && location.Count >= 3)
 
858
                                        newEvent.AddChild (new CSharpTokenNode (Convert (location[2]), 1), CustomEventDeclaration.Roles.RBrace);
550
859
                                
551
 
                                typeStack.Peek ().AddChild (newEvent, TypeDeclaration.Roles.Member);
 
860
                                typeStack.Peek ().AddChild (newEvent, TypeDeclaration.MemberRole);
552
861
                        }
553
862
                        
554
863
                        #endregion
555
864
                        
556
865
                        #region Statements
557
 
                        public override object Visit (Statement stmt)
 
866
                        public override object Visit (Mono.CSharp.Statement stmt)
558
867
                        {
559
868
                                Console.WriteLine ("unknown statement:" + stmt);
560
869
                                return null;
561
870
                        }
562
871
                        
 
872
                        public override object Visit (BlockVariableDeclaration blockVariableDeclaration)
 
873
                        {
 
874
                                var result = new VariableDeclarationStatement ();
 
875
                                result.AddChild (ConvertToType (blockVariableDeclaration.TypeExpression), VariableDeclarationStatement.Roles.Type);
 
876
                                
 
877
                                var varInit = new VariableInitializer ();
 
878
                                var location = LocationsBag.GetLocations (blockVariableDeclaration);
 
879
                                varInit.AddChild (CreateIdentifier (blockVariableDeclaration.Variable.Name, Convert (blockVariableDeclaration.Variable.Location)), VariableInitializer.Roles.Identifier);
 
880
                                if (blockVariableDeclaration.Initializer != null) {
 
881
                                        if (location != null)
 
882
                                                varInit.AddChild (new CSharpTokenNode (Convert (location[0]), 1), VariableInitializer.Roles.Assign);
 
883
                                        varInit.AddChild ((MonoDevelop.CSharp.Ast.Expression)blockVariableDeclaration.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 
884
                                }
 
885
                                
 
886
                                result.AddChild (varInit, VariableDeclarationStatement.Roles.Variable);
 
887
                                
 
888
                                if (blockVariableDeclaration.Declarators != null) {
 
889
                                        foreach (var decl in blockVariableDeclaration.Declarators) {
 
890
                                                var loc = LocationsBag.GetLocations (decl);
 
891
                                                var init = new VariableInitializer ();
 
892
                                                if (loc != null && loc.Count > 0)
 
893
                                                        result.AddChild (new CSharpTokenNode (Convert (loc [0]), 1), VariableInitializer.Roles.Comma);
 
894
                                                init.AddChild (CreateIdentifier (decl.Variable.Name, Convert (decl.Variable.Location)), VariableInitializer.Roles.Identifier);
 
895
                                                if (decl.Initializer != null) {
 
896
                                                        if (loc != null && loc.Count > 1)
 
897
                                                                result.AddChild (new CSharpTokenNode (Convert (loc [1]), 1), VariableInitializer.Roles.Assign);
 
898
                                                        init.AddChild ((MonoDevelop.CSharp.Ast.Expression)decl.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 
899
                                                } else {
 
900
                                                }
 
901
                                                result.AddChild (init, VariableDeclarationStatement.Roles.Variable);
 
902
                                        }
 
903
                                }
 
904
                                if (location != null)
 
905
                                        result.AddChild (new CSharpTokenNode (Convert (location[location.Count - 1]), 1), VariableDeclarationStatement.Roles.Semicolon);
 
906
                                return result;
 
907
                        }
 
908
                        
 
909
                        public override object Visit (BlockConstantDeclaration blockVariableDeclaration)
 
910
                        {
 
911
                                var result = new VariableDeclarationStatement ();
 
912
                                
 
913
                                var location = LocationsBag.GetLocations (blockVariableDeclaration);
 
914
                                if (location != null)
 
915
                                        result.AddChild (new CSharpModifierToken (Convert (location [0]), MonoDevelop.Projects.Dom.Modifiers.Const), VariableDeclarationStatement.ModifierRole);
 
916
                                
 
917
                                result.AddChild (ConvertToType (blockVariableDeclaration.TypeExpression), VariableDeclarationStatement.Roles.Type);
 
918
                                
 
919
                                var varInit = new VariableInitializer ();
 
920
                                varInit.AddChild (CreateIdentifier (blockVariableDeclaration.Variable.Name, Convert (blockVariableDeclaration.Variable.Location)), VariableInitializer.Roles.Identifier);
 
921
                                if (blockVariableDeclaration.Initializer != null) {
 
922
                                        if (location != null)
 
923
                                                varInit.AddChild (new CSharpTokenNode (Convert (location[1]), 1), VariableInitializer.Roles.Assign);
 
924
                                        varInit.AddChild ((MonoDevelop.CSharp.Ast.Expression)blockVariableDeclaration.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 
925
                                }
 
926
                                
 
927
                                result.AddChild (varInit, VariableDeclarationStatement.Roles.Variable);
 
928
                                
 
929
                                if (blockVariableDeclaration.Declarators != null) {
 
930
                                        foreach (var decl in blockVariableDeclaration.Declarators) {
 
931
                                                var loc = LocationsBag.GetLocations (decl);
 
932
                                                var init = new VariableInitializer ();
 
933
                                                init.AddChild (CreateIdentifier (decl.Variable.Name, Convert (decl.Variable.Location)), VariableInitializer.Roles.Identifier);
 
934
                                                if (decl.Initializer != null) {
 
935
                                                        if (loc != null)
 
936
                                                                init.AddChild (new CSharpTokenNode (Convert (loc[0]), 1), VariableInitializer.Roles.Assign);
 
937
                                                        init.AddChild ((MonoDevelop.CSharp.Ast.Expression)decl.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 
938
                                                        if (loc != null && loc.Count > 1)
 
939
                                                                result.AddChild (new CSharpTokenNode (Convert (loc[1]), 1), VariableInitializer.Roles.Comma);
 
940
                                                } else {
 
941
                                                        if (loc != null && loc.Count > 0)
 
942
                                                                result.AddChild (new CSharpTokenNode (Convert (loc[0]), 1), VariableInitializer.Roles.Comma);
 
943
                                                }
 
944
                                                result.AddChild (init, VariableDeclarationStatement.Roles.Variable);
 
945
                                        }
 
946
                                }
 
947
                                if (location != null)
 
948
                                        result.AddChild (new CSharpTokenNode (Convert (location[location.Count - 1]), 1), VariableDeclarationStatement.Roles.Semicolon);
 
949
                                return result;
 
950
                        }
 
951
                        
563
952
                        public override object Visit (Mono.CSharp.EmptyStatement emptyStatement)
564
953
                        {
565
 
                                var result = new MonoDevelop.CSharp.Dom.EmptyStatement ();
 
954
                                var result = new MonoDevelop.CSharp.Ast.EmptyStatement ();
566
955
                                result.Location = Convert (emptyStatement.loc);
567
956
                                return result;
568
957
                        }
569
958
                        
570
959
                        public override object Visit (EmptyExpressionStatement emptyExpressionStatement)
571
960
                        {
572
 
                                // indicates an error
573
 
                                return new MonoDevelop.CSharp.Dom.EmptyStatement ();
 
961
                                return new MonoDevelop.CSharp.Ast.EmptyExpression (Convert (emptyExpressionStatement.Location));
574
962
                        }
575
 
                
576
963
                        
577
964
                        public override object Visit (If ifStatement)
578
965
                        {
579
966
                                var result = new IfElseStatement ();
580
967
                                
581
 
                                LocationDescriptor location = LocationStorage.Get (ifStatement);
582
 
                                
583
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "if".Length), IfElseStatement.IfKeywordRole);
584
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), IfElseStatement.Roles.LPar);
585
 
                                result.AddChild ((INode)ifStatement.Expr.Accept (this), IfElseStatement.Roles.Condition);
586
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), IfElseStatement.Roles.RPar);
587
 
                                
588
 
                                result.AddChild ((INode)ifStatement.TrueStatement.Accept (this), IfElseStatement.TrueEmbeddedStatementRole);
 
968
                                var location = LocationsBag.GetLocations (ifStatement);
 
969
                                
 
970
                                result.AddChild (new CSharpTokenNode (Convert (ifStatement.loc), "if".Length), IfElseStatement.IfKeywordRole);
 
971
                                if (location != null)
 
972
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), IfElseStatement.Roles.LPar);
 
973
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)ifStatement.Expr.Accept (this), IfElseStatement.Roles.Condition);
 
974
                                if (location != null)
 
975
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), IfElseStatement.Roles.RPar);
 
976
                                
 
977
                                if (ifStatement.TrueStatement != null)
 
978
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Statement)ifStatement.TrueStatement.Accept (this), IfElseStatement.TrueRole);
589
979
                                
590
980
                                if (ifStatement.FalseStatement != null) {
591
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[3]), "else".Length), IfElseStatement.ElseKeywordRole);
592
 
                                        result.AddChild ((INode)ifStatement.FalseStatement.Accept (this), IfElseStatement.FalseEmbeddedStatementRole);
 
981
                                        if (location != null)
 
982
                                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "else".Length), IfElseStatement.ElseKeywordRole);
 
983
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Statement)ifStatement.FalseStatement.Accept (this), IfElseStatement.FalseRole);
593
984
                                }
594
985
                                
595
986
                                return result;
597
988
                        
598
989
                        public override object Visit (Do doStatement)
599
990
                        {
600
 
                                var result = new WhileStatement (WhilePosition.End);
601
 
                                LocationDescriptor location = LocationStorage.Get (doStatement);
602
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "do".Length), WhileStatement.DoKeywordRole);
603
 
                                result.AddChild ((INode)doStatement.EmbeddedStatement.Accept (this), WhileStatement.Roles.EmbeddedStatement);
604
 
                                result.AddChild (new CSharpTokenNode (Convert (location[3]), "while".Length), WhileStatement.WhileKeywordRole);
605
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), WhileStatement.Roles.LPar);
606
 
                                result.AddChild ((INode)doStatement.expr.Accept (this), WhileStatement.Roles.Condition);
607
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), WhileStatement.Roles.RPar);
608
 
                                result.AddChild (new CSharpTokenNode (Convert (location[4]), 1), WhileStatement.Roles.Semicolon);
 
991
                                var result = new DoWhileStatement ();
 
992
                                var location = LocationsBag.GetLocations (doStatement);
 
993
                                result.AddChild (new CSharpTokenNode (Convert (doStatement.loc), "do".Length), DoWhileStatement.DoKeywordRole);
 
994
                                result.AddChild ((MonoDevelop.CSharp.Ast.Statement)doStatement.EmbeddedStatement.Accept (this), WhileStatement.Roles.EmbeddedStatement);
 
995
                                if (location != null)
 
996
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "while".Length), DoWhileStatement.WhileKeywordRole);
 
997
                                if (location != null)
 
998
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), DoWhileStatement.Roles.LPar);
 
999
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)doStatement.expr.Accept (this), DoWhileStatement.Roles.Condition);
 
1000
                                if (location != null) {
 
1001
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), DoWhileStatement.Roles.RPar);
 
1002
                                        result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), DoWhileStatement.Roles.Semicolon);
 
1003
                                }
609
1004
                                
610
1005
                                return result;
611
1006
                        }
612
1007
                        
613
1008
                        public override object Visit (While whileStatement)
614
1009
                        {
615
 
                                var result = new WhileStatement (WhilePosition.Begin);
616
 
                                LocationDescriptor location = LocationStorage.Get (whileStatement);
617
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "while".Length), WhileStatement.WhileKeywordRole);
618
 
                                
619
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), WhileStatement.Roles.LPar);
620
 
                                result.AddChild ((INode)whileStatement.expr.Accept (this), WhileStatement.Roles.Condition);
621
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), WhileStatement.Roles.RPar);
622
 
                                
623
 
                                result.AddChild ((INode)whileStatement.Statement.Accept (this), WhileStatement.Roles.EmbeddedStatement);
 
1010
                                var result = new WhileStatement ();
 
1011
                                var location = LocationsBag.GetLocations (whileStatement);
 
1012
                                result.AddChild (new CSharpTokenNode (Convert (whileStatement.loc), "while".Length), WhileStatement.WhileKeywordRole);
 
1013
                                
 
1014
                                if (location != null)
 
1015
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), WhileStatement.Roles.LPar);
 
1016
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)whileStatement.expr.Accept (this), WhileStatement.Roles.Condition);
 
1017
                                if (location != null)
 
1018
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), WhileStatement.Roles.RPar);
 
1019
                                result.AddChild ((MonoDevelop.CSharp.Ast.Statement)whileStatement.Statement.Accept (this), WhileStatement.Roles.EmbeddedStatement);
624
1020
                                
625
1021
                                return result;
626
1022
                        }
627
1023
                        
 
1024
                        void AddStatementOrList (ForStatement forStatement, Mono.CSharp.Statement init, Role<MonoDevelop.CSharp.Ast.Statement> role)
 
1025
                        {
 
1026
                                if (init == null)
 
1027
                                        return;
 
1028
                                if (init is StatementList) {
 
1029
                                        foreach (var stmt in ((StatementList)init).Statements) {
 
1030
                                                forStatement.AddChild ((MonoDevelop.CSharp.Ast.Statement)stmt.Accept (this), role);
 
1031
                                        }
 
1032
                                } else {
 
1033
                                        forStatement.AddChild ((MonoDevelop.CSharp.Ast.Statement)init.Accept (this), role);
 
1034
                                }
 
1035
                        }
 
1036
 
628
1037
                        public override object Visit (For forStatement)
629
1038
                        {
630
1039
                                var result = new ForStatement ();
631
1040
                                
632
 
                                LocationDescriptor location = LocationStorage.Get (forStatement);
633
 
                                
634
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "for".Length), ForStatement.Roles.Keyword);
635
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ForStatement.Roles.LPar);
636
 
                                if (forStatement.InitStatement != null)
637
 
                                        result.AddChild ((INode)forStatement.InitStatement.Accept (this), ForStatement.Roles.Initializer);
638
 
                                
639
 
                                result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), ForStatement.Roles.Semicolon);
 
1041
                                var location = LocationsBag.GetLocations (forStatement);
 
1042
                                
 
1043
                                result.AddChild (new CSharpTokenNode (Convert (forStatement.loc), "for".Length), ForStatement.Roles.Keyword);
 
1044
                                if (location != null)
 
1045
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ForStatement.Roles.LPar);
 
1046
                                
 
1047
                                AddStatementOrList (result, forStatement.InitStatement, ForStatement.InitializerRole);
 
1048
                                
 
1049
                                if (location != null)
 
1050
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ForStatement.Roles.Semicolon);
640
1051
                                if (forStatement.Test != null)
641
 
                                        result.AddChild ((INode)forStatement.Test.Accept (this), ForStatement.Roles.Condition);
642
 
                                result.AddChild (new CSharpTokenNode (Convert (location[4]), 1), ForStatement.Roles.Semicolon);
643
 
                                if (forStatement.Increment != null)
644
 
                                        result.AddChild ((INode)forStatement.Increment.Accept (this), ForStatement.Roles.Iterator);
645
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ForStatement.Roles.RPar);
646
 
                                
647
 
                                result.AddChild ((INode)forStatement.Statement.Accept (this), ForStatement.Roles.EmbeddedStatement);
 
1052
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)forStatement.Test.Accept (this), ForStatement.Roles.Condition);
 
1053
                                if (location != null)
 
1054
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), ForStatement.Roles.Semicolon);
 
1055
                                
 
1056
                                AddStatementOrList (result, forStatement.Increment, ForStatement.IteratorRole);
 
1057
                                
 
1058
                                if (location != null)
 
1059
                                        result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), ForStatement.Roles.RPar);
 
1060
                                
 
1061
                                result.AddChild ((MonoDevelop.CSharp.Ast.Statement)forStatement.Statement.Accept (this), ForStatement.Roles.EmbeddedStatement);
648
1062
                                
649
1063
                                return result;
650
1064
                        }
651
1065
                        
652
1066
                        public override object Visit (StatementExpression statementExpression)
653
1067
                        {
654
 
                                var result = new MonoDevelop.CSharp.Dom.ExpressionStatement ();
655
 
                                LocationDescriptor location = LocationStorage.Get (statementExpression);
656
 
                                
657
 
                                result.AddChild ((INode)statementExpression.Expr.Accept (this), MonoDevelop.CSharp.Dom.ExpressionStatement.Roles.Expression);
658
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MonoDevelop.CSharp.Dom.ExpressionStatement.Roles.Semicolon);
 
1068
                                var result = new MonoDevelop.CSharp.Ast.ExpressionStatement ();
 
1069
                                object expr = statementExpression.Expr.Accept (this);
 
1070
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)expr, MonoDevelop.CSharp.Ast.ExpressionStatement.Roles.Expression);
 
1071
                                var location = LocationsBag.GetLocations (statementExpression);
 
1072
                                if (location != null)
 
1073
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MonoDevelop.CSharp.Ast.ExpressionStatement.Roles.Semicolon);
659
1074
                                return result;
660
1075
                        }
661
1076
                        
662
1077
                        public override object Visit (Return returnStatement)
663
1078
                        {
664
1079
                                var result = new ReturnStatement ();
665
 
                                LocationDescriptor location = LocationStorage.Get (returnStatement);
666
1080
                                
667
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "return".Length), ReturnStatement.Roles.Keyword);
 
1081
                                result.AddChild (new CSharpTokenNode (Convert (returnStatement.loc), "return".Length), ReturnStatement.Roles.Keyword);
668
1082
                                if (returnStatement.Expr != null)
669
 
                                        result.AddChild ((INode)returnStatement.Expr.Accept (this), ReturnStatement.Roles.Expression);
670
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ReturnStatement.Roles.Semicolon);
 
1083
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)returnStatement.Expr.Accept (this), ReturnStatement.Roles.Expression);
 
1084
                                
 
1085
                                var location = LocationsBag.GetLocations (returnStatement);
 
1086
                                if (location != null)
 
1087
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ReturnStatement.Roles.Semicolon);
671
1088
                                
672
1089
                                return result;
673
1090
                        }
674
1091
                        
675
1092
                        public override object Visit (Goto gotoStatement)
676
1093
                        {
677
 
                                var result = new GotoStatement (GotoType.Label);
678
 
                                LocationDescriptor location = LocationStorage.Get (gotoStatement);
679
 
                                
680
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "goto".Length), GotoStatement.Roles.Keyword);
681
 
                                result.AddChild (new Identifier (gotoStatement.Target, Convert (gotoStatement.loc)), GotoStatement.Roles.Identifier);
682
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), GotoStatement.Roles.Semicolon);
 
1094
                                var result = new GotoStatement ();
 
1095
                                var location = LocationsBag.GetLocations (gotoStatement);
 
1096
                                result.AddChild (new CSharpTokenNode (Convert (gotoStatement.loc), "goto".Length), GotoStatement.Roles.Keyword);
 
1097
                                result.AddChild (CreateIdentifier (gotoStatement.Target, Convert (gotoStatement.loc)), GotoStatement.Roles.Identifier);
 
1098
                                if (location != null)
 
1099
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), GotoStatement.Roles.Semicolon);
683
1100
                                
684
1101
                                return result;
685
1102
                        }
687
1104
                        public override object Visit (LabeledStatement labeledStatement)
688
1105
                        {
689
1106
                                var result = new LabelStatement ();
690
 
                                result.AddChild (new Identifier (labeledStatement.Name, Convert (labeledStatement.loc)), LabelStatement.Roles.Identifier);
 
1107
                                result.AddChild (CreateIdentifier (labeledStatement.Name, Convert (labeledStatement.loc)), LabelStatement.Roles.Identifier);
691
1108
                                return result;
692
1109
                        }
693
1110
                        
694
1111
                        public override object Visit (GotoDefault gotoDefault)
695
1112
                        {
696
 
                                var result = new GotoStatement (GotoType.CaseDefault);
697
 
                                LocationDescriptor location = LocationStorage.Get (gotoDefault);
698
 
                                
699
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "goto".Length), GotoStatement.Roles.Keyword);
700
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "default".Length), GotoStatement.DefaultKeywordRole);
701
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), GotoStatement.Roles.Semicolon);
 
1113
                                var result = new GotoDefaultStatement ();
 
1114
                                result.AddChild (new CSharpTokenNode (Convert (gotoDefault.loc), "goto".Length), GotoDefaultStatement.Roles.Keyword);
 
1115
                                var location = LocationsBag.GetLocations (gotoDefault);
 
1116
                                if (location != null) {
 
1117
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "default".Length), GotoDefaultStatement.DefaultKeywordRole);
 
1118
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), GotoDefaultStatement.Roles.Semicolon);
 
1119
                                }
702
1120
                                
703
1121
                                return result;
704
1122
                        }
705
1123
                        
706
1124
                        public override object Visit (GotoCase gotoCase)
707
1125
                        {
708
 
                                var result = new GotoStatement (GotoType.Case);
709
 
                                LocationDescriptor location = LocationStorage.Get (gotoCase);
 
1126
                                var result = new GotoCaseStatement ();
 
1127
                                result.AddChild (new CSharpTokenNode (Convert (gotoCase.loc), "goto".Length), GotoCaseStatement.Roles.Keyword);
710
1128
                                
711
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "goto".Length), GotoStatement.Roles.Keyword);
712
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "case".Length), GotoStatement.CaseKeywordRole);
713
 
                                result.AddChild ((INode)gotoCase.Expr.Accept (this), GotoStatement.Roles.Expression);
714
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), GotoStatement.Roles.Semicolon);
 
1129
                                var location = LocationsBag.GetLocations (gotoCase);
 
1130
                                if (location != null)
 
1131
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "case".Length), GotoCaseStatement.CaseKeywordRole);
 
1132
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)gotoCase.Expr.Accept (this), GotoCaseStatement.Roles.Expression);
 
1133
                                if (location != null)
 
1134
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), GotoCaseStatement.Roles.Semicolon);
715
1135
                                return result;
716
1136
                        }
717
1137
                        
718
1138
                        public override object Visit (Throw throwStatement)
719
1139
                        {
720
1140
                                var result = new ThrowStatement ();
721
 
                                LocationDescriptor location = LocationStorage.Get (throwStatement);
 
1141
                                var location = LocationsBag.GetLocations (throwStatement);
722
1142
                                
723
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "throw".Length), ThrowStatement.Roles.Keyword);
 
1143
                                result.AddChild (new CSharpTokenNode (Convert (throwStatement.loc), "throw".Length), ThrowStatement.Roles.Keyword);
724
1144
                                if (throwStatement.Expr != null)
725
 
                                        result.AddChild ((INode)throwStatement.Expr.Accept (this), ThrowStatement.Roles.Expression);
726
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ThrowStatement.Roles.Semicolon);
 
1145
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)throwStatement.Expr.Accept (this), ThrowStatement.Roles.Expression);
 
1146
                                if (location != null)
 
1147
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ThrowStatement.Roles.Semicolon);
727
1148
                                return result;
728
1149
                        }
729
1150
                        
730
1151
                        public override object Visit (Break breakStatement)
731
1152
                        {
732
1153
                                var result = new BreakStatement ();
733
 
                                LocationDescriptor location = LocationStorage.Get (breakStatement);
 
1154
                                var location = LocationsBag.GetLocations (breakStatement);
734
1155
                                
735
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "break".Length), BreakStatement.Roles.Keyword);
736
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), BreakStatement.Roles.Semicolon);
 
1156
                                result.AddChild (new CSharpTokenNode (Convert (breakStatement.loc), "break".Length), BreakStatement.Roles.Keyword);
 
1157
                                if (location != null)
 
1158
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), BreakStatement.Roles.Semicolon);
737
1159
                                return result;
738
1160
                        }
739
1161
                        
740
1162
                        public override object Visit (Continue continueStatement)
741
1163
                        {
742
1164
                                var result = new ContinueStatement ();
743
 
                                LocationDescriptor location = LocationStorage.Get (continueStatement);
744
 
                                
745
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "continue".Length), ContinueStatement.Roles.Keyword);
746
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ContinueStatement.Roles.Semicolon);
 
1165
                                var location = LocationsBag.GetLocations (continueStatement);
 
1166
                                result.AddChild (new CSharpTokenNode (Convert (continueStatement.loc), "continue".Length), ContinueStatement.Roles.Keyword);
 
1167
                                if (location != null)
 
1168
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ContinueStatement.Roles.Semicolon);
747
1169
                                return result;
748
1170
                        }
749
1171
                        
751
1173
                        {
752
1174
                                return left.Row < right.Row || left.Row == right.Row && left.Column < right.Column;
753
1175
                        }
 
1176
                        
 
1177
                        public UsingStatement CreateUsingStatement (Block blockStatement)
 
1178
                        {
 
1179
                                var usingResult = new UsingStatement ();
 
1180
                                Mono.CSharp.Statement cur = blockStatement.Statements[0];
 
1181
                                if (cur is Using) {
 
1182
                                        Using u = (Using)cur;
 
1183
                                        usingResult.AddChild (new CSharpTokenNode (Convert (u.loc), "using".Length), UsingStatement.Roles.Keyword);
 
1184
                                        usingResult.AddChild (new CSharpTokenNode (Convert (blockStatement.StartLocation), 1), UsingStatement.Roles.LPar);
 
1185
                                        if (u.Variables != null) {
 
1186
                                                usingResult.AddChild (ConvertToType (u.Variables.TypeExpression), UsingStatement.Roles.Type);
 
1187
                                                usingResult.AddChild (CreateIdentifier (u.Variables.Variable.Name, Convert (u.Variables.Variable.Location)), UsingStatement.Roles.Identifier);
 
1188
                                                var loc = LocationsBag.GetLocations (u.Variables);
 
1189
                                                if (loc != null)
 
1190
                                                        usingResult.AddChild (new CSharpTokenNode (Convert (loc[1]), 1), ContinueStatement.Roles.Assign);
 
1191
                                                if (u.Variables.Initializer != null)
 
1192
                                                        usingResult.AddChild ((AstNode)u.Variables.Initializer.Accept (this), UsingStatement.ResourceAcquisitionRole);
 
1193
                                                
 
1194
                                        }
 
1195
                                        cur = u.Statement;
 
1196
                                        usingResult.AddChild (new CSharpTokenNode (Convert (blockStatement.EndLocation), 1), UsingStatement.Roles.RPar);
 
1197
                                        usingResult.AddChild ((MonoDevelop.CSharp.Ast.Statement)cur.Accept (this), UsingStatement.Roles.EmbeddedStatement);
 
1198
                                }
 
1199
                                return usingResult;
 
1200
                        }
 
1201
                        
 
1202
                        void AddBlockChildren (BlockStatement result, Block blockStatement, ref int curLocal)
 
1203
                        {
 
1204
                                foreach (Mono.CSharp.Statement stmt in blockStatement.Statements) {
 
1205
                                        if (stmt == null)
 
1206
                                                continue;
 
1207
                                        /*                                      if (curLocal < localVariables.Count && IsLower (localVariables[curLocal].Location, stmt.loc)) {
 
1208
                                                result.AddChild (CreateVariableDeclaration (localVariables[curLocal]), AstNode.Roles.Statement);
 
1209
                                                curLocal++;
 
1210
                                        }*/
 
1211
                                        if (stmt is Block && !(stmt is ToplevelBlock || stmt is ExplicitBlock)) {
 
1212
                                                AddBlockChildren (result, (Block)stmt, ref curLocal);
 
1213
                                        } else {
 
1214
                                                result.AddChild ((MonoDevelop.CSharp.Ast.Statement)stmt.Accept (this), BlockStatement.StatementRole);
 
1215
                                        }
 
1216
                                }
 
1217
                        }
 
1218
                        
754
1219
                        public override object Visit (Block blockStatement)
755
1220
                        {
756
 
                                if (blockStatement.IsGenerated)
 
1221
                                if (blockStatement.IsCompilerGenerated && blockStatement.Statements.Any ()) {
 
1222
                                        if (blockStatement.Statements.First () is Using)
 
1223
                                                return CreateUsingStatement (blockStatement);
757
1224
                                        return blockStatement.Statements.Last ().Accept (this);
 
1225
                                }
758
1226
                                var result = new BlockStatement ();
759
 
                                result.AddChild (new CSharpTokenNode (Convert (blockStatement.StartLocation), 1), AbstractCSharpNode.Roles.LBrace);
 
1227
                                result.AddChild (new CSharpTokenNode (Convert (blockStatement.StartLocation), 1), AstNode.Roles.LBrace);
760
1228
                                int curLocal = 0;
761
 
                                List<LocalInfo> localVariables = new List<LocalInfo> (blockStatement.Variables.Values);
762
 
                                foreach (Statement stmt in blockStatement.Statements) {
763
 
                                        if (curLocal < localVariables.Count && IsLower (localVariables[curLocal].Location, stmt.loc)) {
764
 
                                                result.AddChild (CreateVariableDeclaration (localVariables[curLocal]), AbstractCSharpNode.Roles.Statement);
765
 
                                                curLocal++;
766
 
                                        }
767
 
                                        result.AddChild ((INode)stmt.Accept (this), AbstractCSharpNode.Roles.Statement);
768
 
                                }
769
 
                                
770
 
                                while (curLocal < localVariables.Count) {
771
 
                                        result.AddChild (CreateVariableDeclaration (localVariables[curLocal]), AbstractCSharpNode.Roles.Statement);
772
 
                                        curLocal++;
773
 
                                }
774
 
                                
775
 
                                result.AddChild (new CSharpTokenNode (Convert (blockStatement.EndLocation), 1), AbstractCSharpNode.Roles.RBrace);
776
 
                                
777
 
                                return result;
778
 
                        }
779
 
                        
780
 
                        VariableDeclarationStatement CreateVariableDeclaration (LocalInfo info)
781
 
                        {
782
 
                                VariableDeclarationStatement result = new VariableDeclarationStatement ();
783
 
                                result.AddChild ((INode)info.Type.Accept (this), CatchClause.Roles.ReturnType);
784
 
                                VariableInitializer variable = new VariableInitializer ();
785
 
                                variable.AddChild (new Identifier (info.Name, Convert (info.Location)), AbstractNode.Roles.Identifier);
786
 
                                result.AddChild (variable, AbstractNode.Roles.Initializer);
787
 
                                
788
 
                                result.AddChild (new Identifier (info.Name, Convert (info.Location)), CatchClause.Roles.ReturnType);
789
 
                                return result;
790
 
                        }
791
 
                        
 
1229
                                AddBlockChildren (result, blockStatement, ref curLocal);
 
1230
                                
 
1231
                                result.AddChild (new CSharpTokenNode (Convert (blockStatement.EndLocation), 1), AstNode.Roles.RBrace);
 
1232
                                return result;
 
1233
                        }
 
1234
 
792
1235
                        public override object Visit (Switch switchStatement)
793
1236
                        {
794
1237
                                var result = new SwitchStatement ();
795
1238
                                
796
 
                                LocationDescriptor location = LocationStorage.Get (switchStatement);
797
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "switch".Length), SwitchStatement.Roles.Keyword);
798
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), SwitchStatement.Roles.LPar);
799
 
                                result.AddChild ((INode)switchStatement.Expr.Accept (this), SwitchStatement.Roles.Expression);
800
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), SwitchStatement.Roles.RPar);
801
 
                                
802
 
                                result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), SwitchStatement.Roles.LBrace);
 
1239
                                var location = LocationsBag.GetLocations (switchStatement);
 
1240
                                result.AddChild (new CSharpTokenNode (Convert (switchStatement.loc), "switch".Length), SwitchStatement.Roles.Keyword);
 
1241
                                if (location != null)
 
1242
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), SwitchStatement.Roles.LPar);
 
1243
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)switchStatement.Expr.Accept (this), SwitchStatement.Roles.Expression);
 
1244
                                if (location != null)
 
1245
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), SwitchStatement.Roles.RPar);
 
1246
                                if (location != null)
 
1247
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), SwitchStatement.Roles.LBrace);
803
1248
                                foreach (var section in switchStatement.Sections) {
804
 
                                        var newSection = new MonoDevelop.CSharp.Dom.SwitchSection ();
 
1249
                                        var newSection = new MonoDevelop.CSharp.Ast.SwitchSection ();
805
1250
                                        foreach (var caseLabel in section.Labels) {
806
1251
                                                var newLabel = new CaseLabel ();
807
1252
                                                newLabel.AddChild (new CSharpTokenNode (Convert (caseLabel.Location), "case".Length), SwitchStatement.Roles.Keyword);
808
1253
                                                if (caseLabel.Label != null)
809
 
                                                        newLabel.AddChild ((INode)caseLabel.Label.Accept (this), SwitchStatement.Roles.Expression);
810
 
                                                
811
 
                                                newSection.AddChild (newLabel, MonoDevelop.CSharp.Dom.SwitchSection.CaseLabelRole);
812
 
                                        }
813
 
                                        newSection.AddChild ((INode)section.Block.Accept (this), MonoDevelop.CSharp.Dom.SwitchSection.Roles.Body);
 
1254
                                                        newLabel.AddChild ((MonoDevelop.CSharp.Ast.Expression)caseLabel.Label.Accept (this), SwitchStatement.Roles.Expression);
 
1255
                                                
 
1256
                                                newSection.AddChild (newLabel, MonoDevelop.CSharp.Ast.SwitchSection.CaseLabelRole);
 
1257
                                        }
 
1258
                                        
 
1259
                                        var blockStatement = section.Block;
 
1260
                                        var bodyBlock = new BlockStatement ();
 
1261
                                        int curLocal = 0;
 
1262
                                        AddBlockChildren (bodyBlock, blockStatement, ref curLocal);
 
1263
                                        foreach (var statement in bodyBlock.Statements) {
 
1264
                                                statement.Remove ();
 
1265
                                                newSection.AddChild (statement, MonoDevelop.CSharp.Ast.SwitchSection.Roles.EmbeddedStatement);
 
1266
                                                
 
1267
                                        }
814
1268
                                        result.AddChild (newSection, SwitchStatement.SwitchSectionRole);
815
1269
                                }
816
1270
                                
817
 
                                result.AddChild (new CSharpTokenNode (Convert (location[4]), 1), SwitchStatement.Roles.RBrace);
 
1271
                                if (location != null)
 
1272
                                        result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), SwitchStatement.Roles.RBrace);
818
1273
                                return result;
819
1274
                        }
820
1275
                        
821
1276
                        public override object Visit (Lock lockStatement)
822
1277
                        {
823
1278
                                var result = new LockStatement ();
824
 
                                LocationDescriptor location = LocationStorage.Get (lockStatement);
825
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "lock".Length), LockStatement.Roles.Keyword);
826
 
                                
827
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), LockStatement.Roles.LPar);
828
 
                                result.AddChild ((INode)lockStatement.Expr.Accept (this), LockStatement.Roles.Expression);
829
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), LockStatement.Roles.RPar);
830
 
                                result.AddChild ((INode)lockStatement.Statement.Accept (this), LockStatement.Roles.EmbeddedStatement);
 
1279
                                var location = LocationsBag.GetLocations (lockStatement);
 
1280
                                result.AddChild (new CSharpTokenNode (Convert (lockStatement.loc), "lock".Length), LockStatement.Roles.Keyword);
 
1281
                                
 
1282
                                if (location != null)
 
1283
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), LockStatement.Roles.LPar);
 
1284
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)lockStatement.Expr.Accept (this), LockStatement.Roles.Expression);
 
1285
                                
 
1286
                                if (location != null)
 
1287
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), LockStatement.Roles.RPar);
 
1288
                                result.AddChild ((MonoDevelop.CSharp.Ast.Statement)lockStatement.Statement.Accept (this), LockStatement.Roles.EmbeddedStatement);
831
1289
                                
832
1290
                                return result;
833
1291
                        }
835
1293
                        public override object Visit (Unchecked uncheckedStatement)
836
1294
                        {
837
1295
                                var result = new UncheckedStatement ();
838
 
                                LocationDescriptor location = LocationStorage.Get (uncheckedStatement);
839
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "unchecked".Length), UncheckedStatement.Roles.Keyword);
840
 
                                result.AddChild ((INode)uncheckedStatement.Block.Accept (this), UncheckedStatement.Roles.EmbeddedStatement);
 
1296
                                result.AddChild (new CSharpTokenNode (Convert (uncheckedStatement.loc), "unchecked".Length), UncheckedStatement.Roles.Keyword);
 
1297
                                result.AddChild ((BlockStatement)uncheckedStatement.Block.Accept (this), UncheckedStatement.Roles.Body);
841
1298
                                return result;
842
1299
                        }
843
1300
                        
845
1302
                        public override object Visit (Checked checkedStatement)
846
1303
                        {
847
1304
                                var result = new CheckedStatement ();
848
 
                                LocationDescriptor location = LocationStorage.Get (checkedStatement);
849
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "checked".Length), CheckedStatement.Roles.Keyword);
850
 
                                result.AddChild ((INode)checkedStatement.Block.Accept (this), CheckedStatement.Roles.EmbeddedStatement);
 
1305
                                result.AddChild (new CSharpTokenNode (Convert (checkedStatement.loc), "checked".Length), CheckedStatement.Roles.Keyword);
 
1306
                                result.AddChild ((BlockStatement)checkedStatement.Block.Accept (this), CheckedStatement.Roles.Body);
851
1307
                                return result;
852
1308
                        }
853
1309
                        
854
1310
                        public override object Visit (Unsafe unsafeStatement)
855
1311
                        {
856
1312
                                var result = new UnsafeStatement ();
857
 
                                LocationDescriptor location = LocationStorage.Get (unsafeStatement);
858
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "unsafe".Length), UnsafeStatement.Roles.Keyword);
859
 
                                result.AddChild ((INode)unsafeStatement.Block.Accept (this), UnsafeStatement.Roles.Body);
 
1313
                                result.AddChild (new CSharpTokenNode (Convert (unsafeStatement.loc), "unsafe".Length), UnsafeStatement.Roles.Keyword);
 
1314
                                result.AddChild ((BlockStatement)unsafeStatement.Block.Accept (this), UnsafeStatement.Roles.Body);
860
1315
                                return result;
861
1316
                        }
862
1317
                        
863
1318
                        public override object Visit (Fixed fixedStatement)
864
1319
                        {
865
1320
                                var result = new FixedStatement ();
866
 
                                LocationDescriptor location = LocationStorage.Get (fixedStatement);
867
 
                                
868
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "fixed".Length), FixedStatement.FixedKeywordRole);
869
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FixedStatement.Roles.LPar);
870
 
                                
871
 
                                result.AddChild ((INode)fixedStatement.Type.Accept (this), FixedStatement.PointerDeclarationRole);
872
 
                                
873
 
                                foreach (KeyValuePair<LocalInfo, Expression> declarator in fixedStatement.Declarators) {
874
 
                                        result.AddChild ((INode)declarator.Value.Accept (this), FixedStatement.DeclaratorRole);
 
1321
                                var location = LocationsBag.GetLocations (fixedStatement);
 
1322
                                
 
1323
                                result.AddChild (new CSharpTokenNode (Convert (fixedStatement.loc), "fixed".Length), FixedStatement.Roles.Keyword);
 
1324
                                if (location != null)
 
1325
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FixedStatement.Roles.LPar);
 
1326
                                
 
1327
                                if (fixedStatement.Variables != null) {
 
1328
//                                      result.AddChild (ConvertToType (fixedStatement.Variables), UsingStatement.Roles.Type);
 
1329
                                        result.AddChild (CreateIdentifier (fixedStatement.Variables.Variable.Name, Convert (fixedStatement.Variables.Variable.Location)), UsingStatement.Roles.Identifier);
 
1330
                                        var loc = LocationsBag.GetLocations (fixedStatement.Variables);
 
1331
                                        if (loc != null)
 
1332
                                                result.AddChild (new CSharpTokenNode (Convert (loc[1]), 1), ContinueStatement.Roles.Assign);
 
1333
//                                      if (fixedStatement.Variables.Initializer != null)
 
1334
//                                              result.AddChild (fixedStatement.Variables.Initializer.Accept (this), UsingStatement.Roles.Variable);
875
1335
                                }
876
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FixedStatement.Roles.RPar);
877
 
                                result.AddChild ((INode)fixedStatement.Statement.Accept (this), FixedStatement.Roles.EmbeddedStatement);
 
1336
                                
 
1337
                                if (location != null)
 
1338
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FixedStatement.Roles.RPar);
 
1339
                                result.AddChild ((MonoDevelop.CSharp.Ast.Statement)fixedStatement.Statement.Accept (this), FixedStatement.Roles.EmbeddedStatement);
878
1340
                                return result;
879
1341
                        }
880
1342
                        
881
1343
                        public override object Visit (TryFinally tryFinallyStatement)
882
1344
                        {
883
1345
                                TryCatchStatement result;
884
 
                                LocationDescriptor location = LocationStorage.Get (tryFinallyStatement);
 
1346
                                var location = LocationsBag.GetLocations (tryFinallyStatement);
885
1347
                                
886
1348
                                if (tryFinallyStatement.Stmt is TryCatch) {
887
1349
                                        result = (TryCatchStatement)tryFinallyStatement.Stmt.Accept (this);
888
1350
                                } else {
889
1351
                                        result = new TryCatchStatement ();
890
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "try".Length), TryCatchStatement.TryKeywordRole);
891
 
                                        result.AddChild ((INode)tryFinallyStatement.Stmt.Accept (this), TryCatchStatement.TryBlockRole);
 
1352
                                        result.AddChild (new CSharpTokenNode (Convert (tryFinallyStatement.loc), "try".Length), TryCatchStatement.TryKeywordRole);
 
1353
                                        result.AddChild ((BlockStatement)tryFinallyStatement.Stmt.Accept (this), TryCatchStatement.TryBlockRole);
892
1354
                                }
893
 
                                
894
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "finally".Length), TryCatchStatement.FinallyKeywordRole);
895
 
                                result.AddChild ((INode)tryFinallyStatement.Fini.Accept (this), TryCatchStatement.FinallyBlockRole);
 
1355
                                if (location != null)
 
1356
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "finally".Length), TryCatchStatement.FinallyKeywordRole);
 
1357
                                result.AddChild ((BlockStatement)tryFinallyStatement.Fini.Accept (this), TryCatchStatement.FinallyBlockRole);
896
1358
                                
897
1359
                                return result;
898
1360
                        }
899
1361
                        
900
 
                        CatchClause ConvertCatch (Catch ctch) 
 
1362
                        CatchClause ConvertCatch (Catch ctch)
901
1363
                        {
902
1364
                                CatchClause result = new CatchClause ();
903
 
                                LocationDescriptor location = LocationStorage.Get (ctch);
904
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "catch".Length), CatchClause.Roles.Keyword);
905
 
                                
906
 
                                if (ctch.Type_expr != null) {
907
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), CatchClause.Roles.LPar);
908
 
                                        
909
 
                                        result.AddChild ((INode)ctch.Type_expr.Accept (this), CatchClause.Roles.ReturnType);
910
 
                                        if (!string.IsNullOrEmpty (ctch.Name))
911
 
                                                result.AddChild (new Identifier (ctch.Name, Convert (location[1])), CatchClause.Roles.Identifier);
912
 
                                        
913
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), CatchClause.Roles.RPar);
 
1365
                                var location = LocationsBag.GetLocations (ctch);
 
1366
                                result.AddChild (new CSharpTokenNode (Convert (ctch.loc), "catch".Length), CatchClause.Roles.Keyword);
 
1367
                                if (ctch.TypeExpression != null) {
 
1368
                                        if (location != null)
 
1369
                                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), CatchClause.Roles.LPar);
 
1370
                                        
 
1371
                                        result.AddChild (ConvertToType (ctch.TypeExpression), CatchClause.Roles.Type);
 
1372
                                        if (ctch.Variable != null && !string.IsNullOrEmpty (ctch.Variable.Name))
 
1373
                                                result.AddChild (CreateIdentifier (ctch.Variable.Name, Convert (ctch.Variable.Location)), CatchClause.Roles.Identifier);
 
1374
                                        
 
1375
                                        if (location != null)
 
1376
                                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), CatchClause.Roles.RPar);
914
1377
                                }
915
1378
                                
916
 
                                result.AddChild ((INode)ctch.Block.Accept (this), CatchClause.Roles.Body);
 
1379
                                result.AddChild ((BlockStatement)ctch.Block.Accept (this), CatchClause.Roles.Body);
917
1380
                                
918
1381
                                return result;
919
1382
                        }
921
1384
                        public override object Visit (TryCatch tryCatchStatement)
922
1385
                        {
923
1386
                                var result = new TryCatchStatement ();
924
 
                                LocationDescriptor location = LocationStorage.Get (tryCatchStatement);
925
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "try".Length), TryCatchStatement.TryKeywordRole);
926
 
                                result.AddChild ((INode)tryCatchStatement.Block.Accept (this), TryCatchStatement.TryBlockRole);
 
1387
                                result.AddChild (new CSharpTokenNode (Convert (tryCatchStatement.loc), "try".Length), TryCatchStatement.TryKeywordRole);
 
1388
                                result.AddChild ((BlockStatement)tryCatchStatement.Block.Accept (this), TryCatchStatement.TryBlockRole);
927
1389
                                foreach (Catch ctch in tryCatchStatement.Specific) {
928
1390
                                        result.AddChild (ConvertCatch (ctch), TryCatchStatement.CatchClauseRole);
929
1391
                                }
936
1398
                        public override object Visit (Using usingStatement)
937
1399
                        {
938
1400
                                var result = new UsingStatement ();
939
 
                                LocationDescriptor location = LocationStorage.Get (usingStatement);
940
 
                                // TODO: Usings with more than 1 variable are compiled differently using (a) { using (b) { using (c) ...}}
941
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "using".Length), UsingStatement.Roles.Keyword);
942
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), UsingStatement.Roles.LPar);
943
 
                                
944
 
                                if (usingStatement.Var != null)
945
 
                                        result.AddChild ((INode)usingStatement.Var.Accept (this), UsingStatement.Roles.Identifier);
946
 
                                
947
 
                                if (usingStatement.Init != null)
948
 
                                        result.AddChild ((INode)usingStatement.Init.Accept (this), UsingStatement.Roles.Initializer);
949
 
                                
950
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), UsingStatement.Roles.RPar);
951
 
                                
952
 
                                result.AddChild ((INode)usingStatement.EmbeddedStatement.Accept (this), UsingStatement.Roles.EmbeddedStatement);
953
 
                                return result;
954
 
                        }
955
 
                        
956
 
                        public override object Visit (UsingTemporary usingTemporary)
957
 
                        {
958
 
                                var result = new UsingStatement ();
959
 
                                LocationDescriptor location = LocationStorage.Get (usingTemporary);
960
 
                                
961
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "using".Length), UsingStatement.Roles.Keyword);
962
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), UsingStatement.Roles.LPar);
963
 
                                
964
 
                                result.AddChild ((INode)usingTemporary.Expr.Accept (this), UsingStatement.Roles.Initializer);
965
 
                                
966
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), UsingStatement.Roles.RPar);
967
 
                                
968
 
                                result.AddChild ((INode)usingTemporary.Statement.Accept (this), UsingStatement.Roles.EmbeddedStatement);
969
 
                                return result;
970
 
                        }
971
 
                        
 
1401
                                var location = LocationsBag.GetLocations (usingStatement);
 
1402
                                
 
1403
                                result.AddChild (new CSharpTokenNode (Convert (usingStatement.loc), "using".Length), UsingStatement.Roles.Keyword);
 
1404
                                if (location != null)
 
1405
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), UsingStatement.Roles.LPar);
 
1406
                                
 
1407
                                result.AddChild ((AstNode)usingStatement.Expression.Accept (this), UsingStatement.ResourceAcquisitionRole);
 
1408
                                
 
1409
                                if (location != null)
 
1410
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), UsingStatement.Roles.RPar);
 
1411
                                
 
1412
                                result.AddChild ((MonoDevelop.CSharp.Ast.Statement)usingStatement.Statement.Accept (this), UsingStatement.Roles.EmbeddedStatement);
 
1413
                                return result;
 
1414
                        }
972
1415
                        
973
1416
                        public override object Visit (Foreach foreachStatement)
974
1417
                        {
975
1418
                                var result = new ForeachStatement ();
976
1419
                                
977
 
                                LocationDescriptor location = LocationStorage.Get (foreachStatement);
 
1420
                                var location = LocationsBag.GetLocations (foreachStatement);
978
1421
                                
979
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "foreach".Length), ForeachStatement.ForEachKeywordRole);
980
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ForeachStatement.Roles.LPar);
 
1422
                                result.AddChild (new CSharpTokenNode (Convert (foreachStatement.loc), "foreach".Length), ForeachStatement.Roles.Keyword);
 
1423
                                if (location != null)
 
1424
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ForeachStatement.Roles.LPar);
981
1425
                                
982
1426
                                if (foreachStatement.TypeExpr == null)
983
 
                                        result.AddChild ((INode)foreachStatement.TypeExpr.Accept (this), ForeachStatement.Roles.ReturnType);
 
1427
                                        result.AddChild (ConvertToType (foreachStatement.TypeExpr), ForeachStatement.Roles.Type);
984
1428
                                if (foreachStatement.Variable != null)
985
 
                                        result.AddChild ((INode)foreachStatement.Variable.Accept (this), ForeachStatement.Roles.Identifier);
 
1429
                                        result.AddChild (CreateIdentifier (foreachStatement.Variable.Name, Convert (foreachStatement.Variable.Location)), ForeachStatement.Roles.Identifier);
986
1430
                                
987
 
                                result.AddChild (new CSharpTokenNode (Convert (location[3]), "in".Length), ForeachStatement.InKeywordRole);
 
1431
                                if (location != null)
 
1432
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), ForeachStatement.Roles.InKeyword);
988
1433
                                
989
1434
                                if (foreachStatement.Expr != null)
990
 
                                        result.AddChild ((INode)foreachStatement.Expr.Accept (this), ForeachStatement.Roles.Initializer);
 
1435
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)foreachStatement.Expr.Accept (this), ForeachStatement.Roles.Expression);
991
1436
                                
992
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ForeachStatement.Roles.RPar);
993
 
                                result.AddChild ((INode)foreachStatement.Statement.Accept (this), ForeachStatement.Roles.EmbeddedStatement);
 
1437
                                if (location != null)
 
1438
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), ForeachStatement.Roles.RPar);
 
1439
                                result.AddChild ((MonoDevelop.CSharp.Ast.Statement)foreachStatement.Statement.Accept (this), ForeachStatement.Roles.EmbeddedStatement);
994
1440
                                
995
1441
                                return result;
996
1442
                        }
998
1444
                        public override object Visit (Yield yieldStatement)
999
1445
                        {
1000
1446
                                var result = new YieldStatement ();
1001
 
                                LocationDescriptor location = LocationStorage.Get (yieldStatement);
 
1447
                                var location = LocationsBag.GetLocations (yieldStatement);
1002
1448
                                
1003
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "yield".Length), YieldStatement.YieldKeywordRole);
1004
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "return".Length), YieldStatement.ReturnKeywordRole);
 
1449
                                result.AddChild (new CSharpTokenNode (Convert (yieldStatement.loc), "yield".Length), YieldStatement.YieldKeywordRole);
 
1450
                                if (location != null)
 
1451
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "return".Length), YieldStatement.ReturnKeywordRole);
1005
1452
                                if (yieldStatement.Expr != null)
1006
 
                                        result.AddChild ((INode)yieldStatement.Expr.Accept (this), YieldStatement.Roles.Expression);
1007
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), ";".Length), YieldStatement.Roles.Semicolon);
 
1453
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)yieldStatement.Expr.Accept (this), YieldStatement.Roles.Expression);
 
1454
                                if (location != null)
 
1455
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), ";".Length), YieldStatement.Roles.Semicolon);
1008
1456
                                
1009
1457
                                return result;
1010
1458
                        }
1011
1459
                        
1012
1460
                        public override object Visit (YieldBreak yieldBreakStatement)
1013
1461
                        {
1014
 
                                var result = new YieldStatement ();
1015
 
                                LocationDescriptor location = LocationStorage.Get (yieldBreakStatement);
1016
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "yield".Length), YieldStatement.YieldKeywordRole);
1017
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "break".Length), YieldStatement.BreakKeywordRole);
1018
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), ";".Length), YieldStatement.Roles.Semicolon);
 
1462
                                var result = new YieldBreakStatement ();
 
1463
                                var location = LocationsBag.GetLocations (yieldBreakStatement);
 
1464
                                result.AddChild (new CSharpTokenNode (Convert (yieldBreakStatement.loc), "yield".Length), YieldBreakStatement.YieldKeywordRole);
 
1465
                                if (location != null) {
 
1466
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "break".Length), YieldBreakStatement.BreakKeywordRole);
 
1467
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), ";".Length), YieldBreakStatement.Roles.Semicolon);
 
1468
                                }
1019
1469
                                return result;
1020
1470
                        }
1021
1471
                        #endregion
1022
1472
                        
1023
1473
                        #region Expression
1024
 
                        public override object Visit (Expression expression)
 
1474
                        public override object Visit (Mono.CSharp.Expression expression)
1025
1475
                        {
1026
1476
                                Console.WriteLine ("Visit unknown expression:" + expression);
 
1477
                                System.Console.WriteLine (Environment.StackTrace);
1027
1478
                                return null;
1028
1479
                        }
1029
1480
                        
1030
 
                        public override object Visit (TypeLookupExpression typeLookupExpression)
1031
 
                        {
1032
 
                                var result = new FullTypeName ();
1033
 
                                if (!string.IsNullOrEmpty (typeLookupExpression.Namespace)) {
1034
 
                                        result.AddChild (new Identifier (typeLookupExpression.Namespace + "." + typeLookupExpression.Name, Convert (typeLookupExpression.Location)));
1035
 
                                } else {
1036
 
                                        result.AddChild (new Identifier (typeLookupExpression.Name, Convert (typeLookupExpression.Location)));
1037
 
                                }
1038
 
                                return result;
 
1481
                        public override object Visit (Mono.CSharp.DefaultParameterValueExpression defaultParameterValueExpression)
 
1482
                        {
 
1483
                                return defaultParameterValueExpression.Child.Accept (this);
 
1484
                        }
 
1485
 
 
1486
                        public override object Visit (TypeExpression typeExpression)
 
1487
                        {
 
1488
                                return new IdentifierExpression (keywordTable [(int)typeExpression.Type.BuiltinType], Convert (typeExpression.Location));
1039
1489
                        }
1040
1490
 
1041
1491
                        public override object Visit (LocalVariableReference localVariableReference)
1042
1492
                        {
1043
 
                                return new Identifier (localVariableReference.Name, Convert (localVariableReference.Location));;
1044
 
                        }
1045
 
 
 
1493
                                return CreateIdentifier (localVariableReference.Name, Convert (localVariableReference.Location));
 
1494
                        }
 
1495
                        
 
1496
                        public override object Visit (QualifiedAliasMember qualifiedAliasMember)
 
1497
                        {
 
1498
                                var result = new MonoDevelop.CSharp.Ast.MemberType ();
 
1499
                                result.Target = new SimpleType (qualifiedAliasMember.alias, Convert (qualifiedAliasMember.Location));
 
1500
                                result.IsDoubleColon = true;
 
1501
                                var location = LocationsBag.GetLocations (qualifiedAliasMember);
 
1502
                                result.AddChild (new Identifier (qualifiedAliasMember.Name, location != null ? Convert (location [0]) : AstLocation.Empty), MemberReferenceExpression.Roles.Identifier);
 
1503
                                return  new TypeReferenceExpression () { Type = result };
 
1504
                        }
 
1505
                        
1046
1506
                        public override object Visit (MemberAccess memberAccess)
1047
1507
                        {
1048
1508
                                var result = new MemberReferenceExpression ();
1049
 
                                result.AddChild ((INode)memberAccess.Left.Accept (this), MemberReferenceExpression.Roles.TargetExpression);
1050
 
                                result.AddChild (new Identifier (memberAccess.Name, Convert (memberAccess.Location)), MemberReferenceExpression.Roles.Identifier);
 
1509
                                if (memberAccess.LeftExpression != null) {
 
1510
                                        var leftExpr = memberAccess.LeftExpression.Accept (this);
 
1511
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)leftExpr, MemberReferenceExpression.Roles.TargetExpression);
 
1512
                                }
 
1513
                                result.AddChild (CreateIdentifier (memberAccess.Name, Convert (memberAccess.Location)), MemberReferenceExpression.Roles.Identifier);
1051
1514
                                if (memberAccess.TypeArguments != null)  {
1052
 
                                        LocationDescriptor location = LocationStorage.Get (memberAccess);
1053
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MemberReferenceExpression.Roles.LChevron);
 
1515
                                        var location = LocationsBag.GetLocations (memberAccess);
 
1516
                                        if (location != null)
 
1517
                                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MemberReferenceExpression.Roles.LChevron);
1054
1518
                                        AddTypeArguments (result, location, memberAccess.TypeArguments);
1055
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MemberReferenceExpression.Roles.RChevron);
 
1519
                                        if (location != null && location.Count > 1)
 
1520
                                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MemberReferenceExpression.Roles.RChevron);
1056
1521
                                }
1057
1522
                                return result;
1058
1523
                        }
1059
1524
                        
1060
1525
                        public override object Visit (Constant constant)
1061
1526
                        {
1062
 
                                var result = new PrimitiveExpression (constant.GetValue (), Convert (constant.Location), constant.AsString ().Length);
 
1527
                                var result = new PrimitiveExpression (constant.GetValue (), Convert (constant.Location), constant.GetValueAsLiteral ().Length);
1063
1528
                                return result;
1064
1529
                        }
1065
1530
 
1066
1531
                        public override object Visit (SimpleName simpleName)
1067
1532
                        {
1068
 
                                var result = new FullTypeName ();
1069
 
                                result.AddChild (new Identifier (simpleName.Name, Convert (simpleName.Location)), FullTypeName.Roles.Identifier);
 
1533
                                var result = new IdentifierExpression ();
 
1534
                                result.AddChild (CreateIdentifier (simpleName.Name, Convert (simpleName.Location)), IdentifierExpression.Roles.Identifier);
1070
1535
                                if (simpleName.TypeArguments != null)  {
1071
 
                                        LocationDescriptor location = LocationStorage.Get (simpleName);
1072
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FullTypeName.Roles.LChevron);
 
1536
                                        var location = LocationsBag.GetLocations (simpleName);
 
1537
                                        if (location != null)
 
1538
                                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), IdentifierExpression.Roles.LChevron);
1073
1539
                                        AddTypeArguments (result, location, simpleName.TypeArguments);
1074
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FullTypeName.Roles.RChevron);
 
1540
                                        if (location != null && location.Count > 1)
 
1541
                                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), IdentifierExpression.Roles.RChevron);
1075
1542
                                }
1076
1543
                                return result;
1077
1544
                        }
1084
1551
                        
1085
1552
                        public override object Visit (Mono.CSharp.ParenthesizedExpression parenthesizedExpression)
1086
1553
                        {
1087
 
                                var result = new MonoDevelop.CSharp.Dom.ParenthesizedExpression ();
1088
 
                                LocationDescriptor location = LocationStorage.Get (parenthesizedExpression);
1089
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MonoDevelop.CSharp.Dom.ParenthesizedExpression.Roles.LPar);
1090
 
                                result.AddChild ((INode)parenthesizedExpression.Expr.Accept (this), MonoDevelop.CSharp.Dom.ParenthesizedExpression.Roles.Expression);
1091
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MonoDevelop.CSharp.Dom.ParenthesizedExpression.Roles.RPar);
 
1554
                                var result = new MonoDevelop.CSharp.Ast.ParenthesizedExpression ();
 
1555
                                var location = LocationsBag.GetLocations (parenthesizedExpression);
 
1556
                                if (location != null)
 
1557
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MonoDevelop.CSharp.Ast.ParenthesizedExpression.Roles.LPar);
 
1558
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)parenthesizedExpression.Expr.Accept (this), MonoDevelop.CSharp.Ast.ParenthesizedExpression.Roles.Expression);
 
1559
                                if (location != null)
 
1560
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MonoDevelop.CSharp.Ast.ParenthesizedExpression.Roles.RPar);
1092
1561
                                return result;
1093
1562
                        }
1094
1563
                        
1096
1565
                        {
1097
1566
                                var result = new UnaryOperatorExpression ();
1098
1567
                                switch (unaryExpression.Oper) {
1099
 
                                case Unary.Operator.UnaryPlus:
1100
 
                                        result.UnaryOperatorType = UnaryOperatorType.Plus;
1101
 
                                        break;
1102
 
                                case Unary.Operator.UnaryNegation:
1103
 
                                        result.UnaryOperatorType = UnaryOperatorType.Minus;
1104
 
                                        break;
1105
 
                                case Unary.Operator.LogicalNot:
1106
 
                                        result.UnaryOperatorType = UnaryOperatorType.Not;
1107
 
                                        break;
1108
 
                                case Unary.Operator.OnesComplement:
1109
 
                                        result.UnaryOperatorType = UnaryOperatorType.BitNot;
1110
 
                                        break;
1111
 
                                case Unary.Operator.AddressOf:
1112
 
                                        result.UnaryOperatorType = UnaryOperatorType.AddressOf;
1113
 
                                        break;
 
1568
                                        case Unary.Operator.UnaryPlus:
 
1569
                                                result.Operator = UnaryOperatorType.Plus;
 
1570
                                                break;
 
1571
                                        case Unary.Operator.UnaryNegation:
 
1572
                                                result.Operator = UnaryOperatorType.Minus;
 
1573
                                                break;
 
1574
                                        case Unary.Operator.LogicalNot:
 
1575
                                                result.Operator = UnaryOperatorType.Not;
 
1576
                                                break;
 
1577
                                        case Unary.Operator.OnesComplement:
 
1578
                                                result.Operator = UnaryOperatorType.BitNot;
 
1579
                                                break;
 
1580
                                        case Unary.Operator.AddressOf:
 
1581
                                                result.Operator = UnaryOperatorType.AddressOf;
 
1582
                                                break;
1114
1583
                                }
1115
 
                                result.AddChild (new CSharpTokenNode (Convert (unaryExpression.Location), 1), UnaryOperatorExpression.Operator);
1116
 
                                result.AddChild ((INode)unaryExpression.Expr.Accept (this), UnaryOperatorExpression.Roles.Expression);
 
1584
                                result.AddChild (new CSharpTokenNode (Convert (unaryExpression.Location), 1), UnaryOperatorExpression.OperatorRole);
 
1585
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)unaryExpression.Expr.Accept (this), UnaryOperatorExpression.Roles.Expression);
1117
1586
                                return result;
1118
1587
                        }
1119
1588
                        
1121
1590
                        {
1122
1591
                                var result = new UnaryOperatorExpression ();
1123
1592
                                
1124
 
                                INode expression = (INode)unaryMutatorExpression.Expr.Accept (this);
1125
 
                                LocationDescriptor location = LocationStorage.Get (unaryMutatorExpression);
 
1593
                                var expression = (MonoDevelop.CSharp.Ast.Expression)unaryMutatorExpression.Expr.Accept (this);
1126
1594
                                switch (unaryMutatorExpression.UnaryMutatorMode) {
1127
 
                                case UnaryMutator.Mode.PostDecrement:
1128
 
                                        result.UnaryOperatorType = UnaryOperatorType.PostDecrement;
1129
 
                                        result.AddChild (expression, UnaryOperatorExpression.Roles.Expression);
1130
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 2), UnaryOperatorExpression.Operator);
1131
 
                                        break;
1132
 
                                case UnaryMutator.Mode.PostIncrement:
1133
 
                                        result.UnaryOperatorType = UnaryOperatorType.PostIncrement;
1134
 
                                        result.AddChild (expression, UnaryOperatorExpression.Roles.Expression);
1135
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 2), UnaryOperatorExpression.Operator);
1136
 
                                        break;
1137
 
                                        
1138
 
                                case UnaryMutator.Mode.PreIncrement:
1139
 
                                        result.UnaryOperatorType = UnaryOperatorType.Increment;
1140
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 2), UnaryOperatorExpression.Operator);
1141
 
                                        result.AddChild (expression, UnaryOperatorExpression.Roles.Expression);
1142
 
                                        break;
1143
 
                                case UnaryMutator.Mode.PreDecrement:
1144
 
                                        result.UnaryOperatorType = UnaryOperatorType.Decrement;
1145
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 2), UnaryOperatorExpression.Operator);
1146
 
                                        result.AddChild (expression, UnaryOperatorExpression.Roles.Expression);
1147
 
                                        break;
 
1595
                                        case UnaryMutator.Mode.PostDecrement:
 
1596
                                                result.Operator = UnaryOperatorType.PostDecrement;
 
1597
                                                result.AddChild (expression, UnaryOperatorExpression.Roles.Expression);
 
1598
                                                result.AddChild (new CSharpTokenNode (Convert (unaryMutatorExpression.Location), 2), UnaryOperatorExpression.OperatorRole);
 
1599
                                                break;
 
1600
                                        case UnaryMutator.Mode.PostIncrement:
 
1601
                                                result.Operator = UnaryOperatorType.PostIncrement;
 
1602
                                                result.AddChild (expression, UnaryOperatorExpression.Roles.Expression);
 
1603
                                                result.AddChild (new CSharpTokenNode (Convert (unaryMutatorExpression.Location), 2), UnaryOperatorExpression.OperatorRole);
 
1604
                                                break;
 
1605
                                                
 
1606
                                        case UnaryMutator.Mode.PreIncrement:
 
1607
                                                result.Operator = UnaryOperatorType.Increment;
 
1608
                                                result.AddChild (new CSharpTokenNode (Convert (unaryMutatorExpression.Location), 2), UnaryOperatorExpression.OperatorRole);
 
1609
                                                result.AddChild (expression, UnaryOperatorExpression.Roles.Expression);
 
1610
                                                break;
 
1611
                                        case UnaryMutator.Mode.PreDecrement:
 
1612
                                                result.Operator = UnaryOperatorType.Decrement;
 
1613
                                                result.AddChild (new CSharpTokenNode (Convert (unaryMutatorExpression.Location), 2), UnaryOperatorExpression.OperatorRole);
 
1614
                                                result.AddChild (expression, UnaryOperatorExpression.Roles.Expression);
 
1615
                                                break;
1148
1616
                                }
1149
1617
                                
1150
1618
                                return result;
1153
1621
                        public override object Visit (Indirection indirectionExpression)
1154
1622
                        {
1155
1623
                                var result = new UnaryOperatorExpression ();
1156
 
                                result.UnaryOperatorType = UnaryOperatorType.Dereference;
1157
 
                                LocationDescriptor location = LocationStorage.Get (indirectionExpression);
1158
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 2), UnaryOperatorExpression.Operator);
1159
 
                                result.AddChild ((INode)indirectionExpression.Expr.Accept (this), UnaryOperatorExpression.Roles.Expression);
 
1624
                                result.Operator = UnaryOperatorType.Dereference;
 
1625
                                var location = LocationsBag.GetLocations (indirectionExpression);
 
1626
                                if (location != null)
 
1627
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 2), UnaryOperatorExpression.OperatorRole);
 
1628
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)indirectionExpression.Expr.Accept (this), UnaryOperatorExpression.Roles.Expression);
1160
1629
                                return result;
1161
1630
                        }
1162
1631
                        
1163
1632
                        public override object Visit (Is isExpression)
1164
1633
                        {
1165
1634
                                var result = new IsExpression ();
1166
 
                                result.AddChild ((INode)isExpression.Expr.Accept (this), IsExpression.Roles.Expression);
 
1635
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)isExpression.Expr.Accept (this), IsExpression.Roles.Expression);
1167
1636
                                result.AddChild (new CSharpTokenNode (Convert (isExpression.Location), "is".Length), IsExpression.Roles.Keyword);
1168
 
                                result.AddChild ((INode)isExpression.ProbeType.Accept (this), IsExpression.Roles.ReturnType);
 
1637
                                result.AddChild (ConvertToType (isExpression.ProbeType), IsExpression.Roles.Type);
1169
1638
                                return result;
1170
1639
                        }
1171
1640
                        
1172
1641
                        public override object Visit (As asExpression)
1173
1642
                        {
1174
1643
                                var result = new AsExpression ();
1175
 
                                result.AddChild ((INode)asExpression.Expr.Accept (this), AsExpression.Roles.Expression);
 
1644
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)asExpression.Expr.Accept (this), AsExpression.Roles.Expression);
1176
1645
                                result.AddChild (new CSharpTokenNode (Convert (asExpression.Location), "as".Length), AsExpression.Roles.Keyword);
1177
 
                                result.AddChild ((INode)asExpression.ProbeType.Accept (this), AsExpression.Roles.ReturnType);
 
1646
                                result.AddChild (ConvertToType (asExpression.ProbeType), AsExpression.Roles.Type);
1178
1647
                                return result;
1179
1648
                        }
1180
1649
                        
1181
1650
                        public override object Visit (Cast castExpression)
1182
1651
                        {
1183
1652
                                var result = new CastExpression ();
1184
 
                                LocationDescriptor location = LocationStorage.Get (castExpression);
 
1653
                                var location = LocationsBag.GetLocations (castExpression);
1185
1654
                                
1186
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), CastExpression.Roles.LPar);
 
1655
                                result.AddChild (new CSharpTokenNode (Convert (castExpression.Location), 1), CastExpression.Roles.LPar);
1187
1656
                                if (castExpression.TargetType != null)
1188
 
                                        result.AddChild ((INode)castExpression.TargetType.Accept (this), CastExpression.Roles.ReturnType);
1189
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), CastExpression.Roles.RPar);
 
1657
                                        result.AddChild (ConvertToType (castExpression.TargetType), CastExpression.Roles.Type);
 
1658
                                if (location != null)
 
1659
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), CastExpression.Roles.RPar);
1190
1660
                                if (castExpression.Expr != null)
1191
 
                                        result.AddChild ((INode)castExpression.Expr.Accept (this), CastExpression.Roles.Expression);
 
1661
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)castExpression.Expr.Accept (this), CastExpression.Roles.Expression);
1192
1662
                                return result;
1193
1663
                        }
1194
1664
                        
1195
1665
                        public override object Visit (ComposedCast composedCast)
1196
1666
                        {
1197
 
                                var result = new PointerReferenceExpression ();
1198
 
                                result.Dim = composedCast.Dim;
1199
 
                                result.AddChild (new CSharpTokenNode (Convert(composedCast.Location), composedCast.Dim.Length), PointerReferenceExpression.Roles.Argument);
1200
 
                                result.AddChild ((INode)composedCast.Left.Accept (this), PointerReferenceExpression.Roles.TargetExpression);
 
1667
                                var result = new ComposedType ();
 
1668
                                result.AddChild (ConvertToType (composedCast.Left), ComposedType.Roles.Type);
 
1669
                                
 
1670
                                var spec = composedCast.Spec;
 
1671
                                while (spec != null) {
 
1672
                                        if (spec.IsNullable) {
 
1673
                                                result.AddChild (new CSharpTokenNode (Convert (spec.Location), 1), ComposedType.NullableRole);
 
1674
                                        } else if (spec.IsPointer) {
 
1675
                                                result.AddChild (new CSharpTokenNode (Convert (spec.Location), 1), ComposedType.PointerRole);
 
1676
                                        } else {
 
1677
                                                var aSpec = new ArraySpecifier ();
 
1678
                                                aSpec.AddChild (new CSharpTokenNode (Convert (spec.Location), 1), ComposedType.Roles.LBracket);
 
1679
                                                var location = LocationsBag.GetLocations (spec);
 
1680
                                                if (location != null)
 
1681
                                                        aSpec.AddChild (new CSharpTokenNode (Convert (spec.Location), 1), ComposedType.Roles.RBracket);
 
1682
                                                result.AddChild (aSpec, ComposedType.ArraySpecifierRole);
 
1683
                                        }
 
1684
                                        spec = spec.Next;
 
1685
                                }
 
1686
                                
1201
1687
                                return result;
1202
1688
                        }
1203
1689
                        
1204
1690
                        public override object Visit (Mono.CSharp.DefaultValueExpression defaultValueExpression)
1205
1691
                        {
1206
 
                                var result = new MonoDevelop.CSharp.Dom.DefaultValueExpression ();
 
1692
                                var result = new MonoDevelop.CSharp.Ast.DefaultValueExpression ();
1207
1693
                                result.AddChild (new CSharpTokenNode (Convert (defaultValueExpression.Location), "default".Length), CastExpression.Roles.Keyword);
1208
 
                                LocationDescriptor location = LocationStorage.Get (defaultValueExpression);
1209
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), CastExpression.Roles.LPar);
1210
 
                                result.AddChild ((INode)defaultValueExpression.Expr.Accept (this), CastExpression.Roles.ReturnType);
1211
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), CastExpression.Roles.RPar);
 
1694
                                var location = LocationsBag.GetLocations (defaultValueExpression);
 
1695
                                if (location != null)
 
1696
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), CastExpression.Roles.LPar);
 
1697
                                result.AddChild (ConvertToType (defaultValueExpression.Expr), CastExpression.Roles.Type);
 
1698
                                if (location != null)
 
1699
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), CastExpression.Roles.RPar);
1212
1700
                                return result;
1213
1701
                        }
1214
1702
                        
1218
1706
                                int opLength = 1;
1219
1707
                                switch (binaryExpression.Oper) {
1220
1708
                                        case Binary.Operator.Multiply:
1221
 
                                                result.BinaryOperatorType = BinaryOperatorType.Multiply;
 
1709
                                                result.Operator = BinaryOperatorType.Multiply;
1222
1710
                                                break;
1223
1711
                                        case Binary.Operator.Division:
1224
 
                                                result.BinaryOperatorType = BinaryOperatorType.Divide;
 
1712
                                                result.Operator = BinaryOperatorType.Divide;
1225
1713
                                                break;
1226
1714
                                        case Binary.Operator.Modulus:
1227
 
                                                result.BinaryOperatorType = BinaryOperatorType.Modulus;
 
1715
                                                result.Operator = BinaryOperatorType.Modulus;
1228
1716
                                                break;
1229
1717
                                        case Binary.Operator.Addition:
1230
 
                                                result.BinaryOperatorType = BinaryOperatorType.Add;
 
1718
                                                result.Operator = BinaryOperatorType.Add;
1231
1719
                                                break;
1232
1720
                                        case Binary.Operator.Subtraction:
1233
 
                                                result.BinaryOperatorType = BinaryOperatorType.Subtract;
 
1721
                                                result.Operator = BinaryOperatorType.Subtract;
1234
1722
                                                break;
1235
1723
                                        case Binary.Operator.LeftShift:
1236
 
                                                result.BinaryOperatorType = BinaryOperatorType.ShiftLeft;
 
1724
                                                result.Operator = BinaryOperatorType.ShiftLeft;
1237
1725
                                                opLength = 2;
1238
1726
                                                break;
1239
1727
                                        case Binary.Operator.RightShift:
1240
 
                                                result.BinaryOperatorType = BinaryOperatorType.ShiftRight;
 
1728
                                                result.Operator = BinaryOperatorType.ShiftRight;
1241
1729
                                                opLength = 2;
1242
1730
                                                break;
1243
1731
                                        case Binary.Operator.LessThan:
1244
 
                                                result.BinaryOperatorType = BinaryOperatorType.LessThan;
 
1732
                                                result.Operator = BinaryOperatorType.LessThan;
1245
1733
                                                break;
1246
1734
                                        case Binary.Operator.GreaterThan:
1247
 
                                                result.BinaryOperatorType = BinaryOperatorType.GreaterThan;
 
1735
                                                result.Operator = BinaryOperatorType.GreaterThan;
1248
1736
                                                break;
1249
1737
                                        case Binary.Operator.LessThanOrEqual:
1250
 
                                                result.BinaryOperatorType = BinaryOperatorType.LessThanOrEqual;
 
1738
                                                result.Operator = BinaryOperatorType.LessThanOrEqual;
1251
1739
                                                opLength = 2;
1252
1740
                                                break;
1253
1741
                                        case Binary.Operator.GreaterThanOrEqual:
1254
 
                                                result.BinaryOperatorType = BinaryOperatorType.GreaterThanOrEqual;
 
1742
                                                result.Operator = BinaryOperatorType.GreaterThanOrEqual;
1255
1743
                                                opLength = 2;
1256
1744
                                                break;
1257
1745
                                        case Binary.Operator.Equality:
1258
 
                                                result.BinaryOperatorType = BinaryOperatorType.Equality;
 
1746
                                                result.Operator = BinaryOperatorType.Equality;
1259
1747
                                                opLength = 2;
1260
1748
                                                break;
1261
1749
                                        case Binary.Operator.Inequality:
1262
 
                                                result.BinaryOperatorType = BinaryOperatorType.InEquality;
 
1750
                                                result.Operator = BinaryOperatorType.InEquality;
1263
1751
                                                opLength = 2;
1264
1752
                                                break;
1265
1753
                                        case Binary.Operator.BitwiseAnd:
1266
 
                                                result.BinaryOperatorType = BinaryOperatorType.BitwiseAnd;
 
1754
                                                result.Operator = BinaryOperatorType.BitwiseAnd;
1267
1755
                                                break;
1268
1756
                                        case Binary.Operator.ExclusiveOr:
1269
 
                                                result.BinaryOperatorType = BinaryOperatorType.ExclusiveOr;
 
1757
                                                result.Operator = BinaryOperatorType.ExclusiveOr;
1270
1758
                                                break;
1271
1759
                                        case Binary.Operator.BitwiseOr:
1272
 
                                                result.BinaryOperatorType = BinaryOperatorType.BitwiseOr;
 
1760
                                                result.Operator = BinaryOperatorType.BitwiseOr;
1273
1761
                                                break;
1274
1762
                                        case Binary.Operator.LogicalAnd:
1275
 
                                                result.BinaryOperatorType = BinaryOperatorType.LogicalAnd;
 
1763
                                                result.Operator = BinaryOperatorType.ConditionalAnd;
1276
1764
                                                opLength = 2;
1277
1765
                                                break;
1278
1766
                                        case Binary.Operator.LogicalOr:
1279
 
                                                result.BinaryOperatorType = BinaryOperatorType.LogicalOr;
 
1767
                                                result.Operator = BinaryOperatorType.ConditionalOr;
1280
1768
                                                opLength = 2;
1281
1769
                                                break;
1282
1770
                                }
1283
 
                                result.AddChild ((INode)binaryExpression.Left.Accept (this), BinaryOperatorExpression.LeftExpressionRole);
1284
 
                                LocationDescriptor location = LocationStorage.Get (binaryExpression);
1285
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), opLength), BinaryOperatorExpression.OperatorRole);
1286
 
                                result.AddChild ((INode)binaryExpression.Left.Accept (this), BinaryOperatorExpression.RightExpressionRole);
 
1771
                                
 
1772
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)binaryExpression.Left.Accept (this), BinaryOperatorExpression.LeftRole);
 
1773
                                result.AddChild (new CSharpTokenNode (Convert (binaryExpression.Location), opLength), BinaryOperatorExpression.OperatorRole);
 
1774
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)binaryExpression.Right.Accept (this), BinaryOperatorExpression.RightRole);
1287
1775
                                return result;
1288
1776
                        }
1289
1777
                        
1290
1778
                        public override object Visit (Mono.CSharp.Nullable.NullCoalescingOperator nullCoalescingOperator)
1291
1779
                        {
1292
1780
                                var result = new BinaryOperatorExpression ();
1293
 
                                result.BinaryOperatorType = BinaryOperatorType.NullCoalescing;
1294
 
                                result.AddChild ((INode)nullCoalescingOperator.Left.Accept (this), BinaryOperatorExpression.LeftExpressionRole);
1295
 
                                LocationDescriptor location = LocationStorage.Get (nullCoalescingOperator);
1296
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 2), BinaryOperatorExpression.OperatorRole);
1297
 
                                result.AddChild ((INode)nullCoalescingOperator.Left.Accept (this), BinaryOperatorExpression.RightExpressionRole);
 
1781
                                result.Operator = BinaryOperatorType.NullCoalescing;
 
1782
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)nullCoalescingOperator.Left.Accept (this), BinaryOperatorExpression.LeftRole);
 
1783
                                result.AddChild (new CSharpTokenNode (Convert (nullCoalescingOperator.Location), 2), BinaryOperatorExpression.OperatorRole);
 
1784
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)nullCoalescingOperator.Right.Accept (this), BinaryOperatorExpression.RightRole);
1298
1785
                                return result;
1299
1786
                        }
1300
1787
                        
1302
1789
                        {
1303
1790
                                var result = new ConditionalExpression ();
1304
1791
                                
1305
 
                                result.AddChild ((INode)conditionalExpression.Expr.Accept (this), ConditionalExpression.Roles.Condition);
1306
 
                                LocationDescriptor location = LocationStorage.Get (conditionalExpression);
 
1792
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)conditionalExpression.Expr.Accept (this), ConditionalExpression.Roles.Condition);
 
1793
                                var location = LocationsBag.GetLocations (conditionalExpression);
1307
1794
                                
1308
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ConditionalExpression.Roles.QuestionMark);
1309
 
                                result.AddChild ((INode)conditionalExpression.TrueExpr.Accept (this), ConditionalExpression.FalseExpressionRole);
1310
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ConditionalExpression.Roles.Colon);
1311
 
                                result.AddChild ((INode)conditionalExpression.FalseExpr.Accept (this), ConditionalExpression.FalseExpressionRole);
 
1795
                                result.AddChild (new CSharpTokenNode (Convert (conditionalExpression.Location), 1), ConditionalExpression.QuestionMarkRole);
 
1796
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)conditionalExpression.TrueExpr.Accept (this), ConditionalExpression.TrueRole);
 
1797
                                if (location != null)
 
1798
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ConditionalExpression.ColonRole);
 
1799
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)conditionalExpression.FalseExpr.Accept (this), ConditionalExpression.FalseRole);
1312
1800
                                return result;
1313
1801
                        }
1314
1802
                        
1315
 
                        void AddParameter (AbstractCSharpNode parent, Mono.CSharp.ParametersCompiled parameters)
 
1803
                        void AddParameter (AstNode parent, Mono.CSharp.AParametersCollection parameters)
1316
1804
                        {
1317
 
                                if (parameters == null || !parameters.HasParams)
 
1805
                                if (parameters == null)
1318
1806
                                        return;
1319
 
                                LocationDescriptor paramLocation = LocationStorage.Get (parameters);
 
1807
                                var paramLocation = LocationsBag.GetLocations (parameters);
1320
1808
                                
1321
1809
                                for (int i = 0; i < parameters.Count; i++) {
1322
 
                                        if (paramLocation.LocationList != null && i > 0 && i - 1 < paramLocation.LocationList.Count) 
1323
 
                                                parent.AddChild (new CSharpTokenNode (Convert (paramLocation.LocationList[i - 1]), 1), ParameterDeclarationExpression.Roles.Comma);
1324
 
                                        Parameter p = parameters[i];
1325
 
                                        LocationDescriptor location = LocationStorage.Get (p);
 
1810
                                        if (paramLocation != null && i > 0 && i - 1 < paramLocation.Count)
 
1811
                                                parent.AddChild (new CSharpTokenNode (Convert (paramLocation [i - 1]), 1), ParameterDeclaration.Roles.Comma);
 
1812
                                        var p = (Parameter)parameters.FixedParameters [i];
 
1813
                                        var location = LocationsBag.GetLocations (p);
1326
1814
                                        
1327
 
                                        ParameterDeclarationExpression parameterDeclarationExpression = new ParameterDeclarationExpression ();
1328
 
                                        switch (p.ParameterModifier) {
 
1815
                                        ParameterDeclaration parameterDeclarationExpression = new ParameterDeclaration ();
 
1816
                                        switch (p.ModFlags) {
1329
1817
                                        case Parameter.Modifier.OUT:
1330
1818
                                                parameterDeclarationExpression.ParameterModifier = ParameterModifier.Out;
1331
 
                                                parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location.LocationList[0]), "out".Length), ParameterDeclarationExpression.Roles.Keyword);
 
1819
                                                if (location != null)
 
1820
                                                        parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location [0]), "out".Length), ParameterDeclaration.Roles.Keyword);
1332
1821
                                                break;
1333
1822
                                        case Parameter.Modifier.REF:
1334
1823
                                                parameterDeclarationExpression.ParameterModifier = ParameterModifier.Ref;
1335
 
                                                parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location.LocationList[0]), "ref".Length), ParameterDeclarationExpression.Roles.Keyword);
 
1824
                                                if (location != null)
 
1825
                                                        parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location [0]), "ref".Length), ParameterDeclaration.Roles.Keyword);
1336
1826
                                                break;
1337
1827
                                        case Parameter.Modifier.PARAMS:
1338
1828
                                                parameterDeclarationExpression.ParameterModifier = ParameterModifier.Params;
1339
 
                                                parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location.LocationList[0]), "params".Length), ParameterDeclarationExpression.Roles.Keyword);
1340
 
                                                break;
1341
 
                                        case Parameter.Modifier.This:
1342
 
                                                parameterDeclarationExpression.ParameterModifier = ParameterModifier.This;
1343
 
                                                parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location.LocationList[0]), "this".Length), ParameterDeclarationExpression.Roles.Keyword);
1344
 
                                                break;
1345
 
                                        }
1346
 
                                        parameterDeclarationExpression.AddChild ((INode)p.TypeName.Accept (this), ParameterDeclarationExpression.Roles.ReturnType);
1347
 
                                        parameterDeclarationExpression.AddChild (new Identifier (p.Name, Convert (p.Location)), ParameterDeclarationExpression.Roles.Identifier);
1348
 
                                        if (p.DefaultExpression != null) {
1349
 
                                                parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ParameterDeclarationExpression.Roles.Assign);
1350
 
                                                parameterDeclarationExpression.AddChild ((INode)p.DefaultExpression.Accept (this), ParameterDeclarationExpression.Roles.Expression);
1351
 
                                        }
1352
 
                                        parent.AddChild (parameterDeclarationExpression, InvocationExpression.Roles.Argument);
1353
 
                                }
1354
 
                        }
1355
 
 
1356
 
                        void AddTypeArguments (AbstractCSharpNode parent, LocationDescriptor location, Mono.CSharp.TypeArguments typeArguments)
1357
 
                        {
1358
 
                                if (typeArguments == null)
1359
 
                                        return;
1360
 
                                for (int i = 0; i < typeArguments.Count; i++) {
1361
 
                                        if (location.LocationList != null && i > 0 && i - 1 < location.LocationList.Count)
1362
 
                                                parent.AddChild (new CSharpTokenNode (Convert (location.LocationList[i - 1]), 1), InvocationExpression.Roles.Comma);
1363
 
                                        parent.AddChild ((INode)typeArguments.Args[i].Accept (this), InvocationExpression.Roles.TypeArgument);
1364
 
                                }
1365
 
                        }
1366
 
                        
1367
 
                        void AddConstraints (AbstractCSharpNode parent, DeclSpace d)
 
1829
                                                if (location != null)
 
1830
                                                        parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location [0]), "params".Length), ParameterDeclaration.Roles.Keyword);
 
1831
                                                break;
 
1832
                                        default:
 
1833
                                                if (p.HasExtensionMethodModifier) {
 
1834
                                                        parameterDeclarationExpression.ParameterModifier = ParameterModifier.This;
 
1835
                                                        if (location != null)
 
1836
                                                                parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location [0]), "this".Length), ParameterDeclaration.Roles.Keyword);
 
1837
                                                }
 
1838
                                                break;
 
1839
                                        }
 
1840
                                        if (p.TypeExpression != null) // lambdas may have no types (a, b) => ...
 
1841
                                                parameterDeclarationExpression.AddChild (ConvertToType (p.TypeExpression), ParameterDeclaration.Roles.Type);
 
1842
                                        parameterDeclarationExpression.AddChild (CreateIdentifier (p.Name, Convert (p.Location)), ParameterDeclaration.Roles.Identifier);
 
1843
                                        if (p.HasDefaultValue) {
 
1844
                                                if (location != null)
 
1845
                                                        parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location [1]), 1), ParameterDeclaration.Roles.Assign);
 
1846
                                                parameterDeclarationExpression.AddChild ((MonoDevelop.CSharp.Ast.Expression)p.DefaultValue.Accept (this), ParameterDeclaration.Roles.Expression);
 
1847
                                        }
 
1848
                                        parent.AddChild (parameterDeclarationExpression, InvocationExpression.Roles.Parameter);
 
1849
                                }
 
1850
                        }
 
1851
                        
 
1852
                        Identifier CreateIdentifier (string name, AstLocation loc)
 
1853
                        {
 
1854
                                bool isQuoted = name != null ? name.StartsWith ("@") : false;
 
1855
                                string id = isQuoted ? name.Substring (1) : name;
 
1856
                                return new Identifier (id ?? "", loc) { IsQuoted = isQuoted };
 
1857
                        }
 
1858
                        
 
1859
                        void AddTypeParameters (AstNode parent, List<Location> location, Mono.CSharp.TypeArguments typeArguments)
 
1860
                        {
 
1861
                                if (typeArguments == null || typeArguments.IsEmpty)
 
1862
                                        return;
 
1863
                                for (int i = 0; i < typeArguments.Count; i++) {
 
1864
                                        if (location != null && i > 0 && i - 1 < location.Count)
 
1865
                                                parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
 
1866
                                        var arg = (TypeParameterName)typeArguments.Args[i];
 
1867
                                        if (arg == null)
 
1868
                                                continue;
 
1869
                                        TypeParameterDeclaration tp = new TypeParameterDeclaration();
 
1870
                                        // TODO: attributes
 
1871
                                        if (arg.Variance != Variance.None)
 
1872
                                                throw new NotImplementedException(); // TODO: variance
 
1873
                                        tp.AddChild (CreateIdentifier (arg.Name, Convert (arg.Location)), InvocationExpression.Roles.Identifier);
 
1874
                                        parent.AddChild (tp, InvocationExpression.Roles.TypeParameter);
 
1875
                                }
 
1876
                        }
 
1877
                        
 
1878
                        void AddTypeArguments (AstNode parent, LocationsBag.MemberLocations location, Mono.CSharp.TypeArguments typeArguments)
 
1879
                        {
 
1880
                                if (typeArguments == null || typeArguments.IsEmpty)
 
1881
                                        return;
 
1882
                                for (int i = 0; i < typeArguments.Count; i++) {
 
1883
                                        if (location != null && i > 0 && i - 1 < location.Count)
 
1884
                                                parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
 
1885
                                        var arg = typeArguments.Args[i];
 
1886
                                        if (arg == null)
 
1887
                                                continue;
 
1888
                                        parent.AddChild (ConvertToType (arg), InvocationExpression.Roles.TypeArgument);
 
1889
                                }
 
1890
                        }
 
1891
                        
 
1892
                        void AddTypeArguments (AstNode parent, List<Location> location, Mono.CSharp.TypeArguments typeArguments)
 
1893
                        {
 
1894
                                if (typeArguments == null || typeArguments.IsEmpty)
 
1895
                                        return;
 
1896
                                for (int i = 0; i < typeArguments.Count; i++) {
 
1897
                                        if (location != null && i > 0 && i - 1 < location.Count)
 
1898
                                                parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
 
1899
                                        var arg = typeArguments.Args[i];
 
1900
                                        if (arg == null)
 
1901
                                                continue;
 
1902
                                        parent.AddChild (ConvertToType (arg), InvocationExpression.Roles.TypeArgument);
 
1903
                                }
 
1904
                        }
 
1905
                        
 
1906
                        void AddConstraints (AstNode parent, DeclSpace d)
1368
1907
                        {
1369
1908
                                if (d == null || d.Constraints == null)
1370
1909
                                        return;
1371
1910
                                for (int i = 0; i < d.Constraints.Count; i++) {
1372
 
                                        Constraints c = d.Constraints[i];
1373
 
                                        LocationDescriptor location = LocationStorage.Get (c);
 
1911
                                        Constraints c = d.Constraints [i];
 
1912
                                        var location = LocationsBag.GetLocations (c);
1374
1913
                                        var constraint = new Constraint ();
1375
 
                                        parent.AddChild (new CSharpTokenNode (Convert (location[0]), "where".Length), InvocationExpression.Roles.Keyword);
1376
 
                                        parent.AddChild (new Identifier (c.TypeParameter.Value, Convert (c.TypeParameter.Location)), InvocationExpression.Roles.Identifier);
1377
 
                                        parent.AddChild (new CSharpTokenNode (Convert (location[1]), 1), InvocationExpression.Roles.Colon);
 
1914
                                        constraint.AddChild (new CSharpTokenNode (Convert (location [0]), "where".Length), InvocationExpression.Roles.Keyword);
 
1915
                                        constraint.AddChild (CreateIdentifier (c.TypeParameter.Value, Convert (c.TypeParameter.Location)), InvocationExpression.Roles.Identifier);
 
1916
                                        constraint.AddChild (new CSharpTokenNode (Convert (location [1]), 1), Constraint.ColonRole);
1378
1917
                                        foreach (var expr in c.ConstraintExpressions)
1379
 
                                                parent.AddChild ((INode)expr.Accept (this), InvocationExpression.Roles.TypeArgument);
 
1918
                                                constraint.AddChild (ConvertToType (expr), Constraint.BaseTypeRole);
 
1919
                                        parent.AddChild (constraint, AstNode.Roles.Constraint);
1380
1920
                                }
1381
1921
                        }
1382
1922
                        
1383
 
                        void AddArguments (AbstractCSharpNode parent, LocationDescriptor location, Mono.CSharp.Arguments args)
 
1923
                        void AddArguments (AstNode parent, object location, Mono.CSharp.Arguments args)
1384
1924
                        {
1385
1925
                                if (args == null)
1386
1926
                                        return;
 
1927
                                
 
1928
                                var commaLocations = LocationsBag.GetLocations (args);
 
1929
                                
1387
1930
                                for (int i = 0; i < args.Count; i++) {
1388
 
                                        if (location.LocationList != null && i > 0 && i - 1 < location.LocationList.Count)
1389
 
                                                parent.AddChild (new CSharpTokenNode (Convert (location.LocationList[i - 1]), 1), InvocationExpression.Roles.Comma);
1390
 
                                        parent.AddChild ((INode)args[i].Expr.Accept (this), InvocationExpression.Roles.Argument);
 
1931
                                        Argument arg = args[i];
 
1932
                                        if (arg.ArgType == Argument.AType.Out || arg.ArgType == Argument.AType.Ref) {
 
1933
                                                DirectionExpression direction = new DirectionExpression ();
 
1934
                                                direction.FieldDirection = arg.ArgType == Argument.AType.Out ? FieldDirection.Out : FieldDirection.Ref;
 
1935
                                                var argLocation = LocationsBag.GetLocations (arg);
 
1936
                                                if (argLocation != null)
 
1937
                                                        direction.AddChild (new CSharpTokenNode (Convert (argLocation[0]), "123".Length), InvocationExpression.Roles.Keyword);
 
1938
                                                direction.AddChild ((MonoDevelop.CSharp.Ast.Expression)arg.Expr.Accept (this), InvocationExpression.Roles.Expression);
 
1939
                                                
 
1940
                                                parent.AddChild (direction, InvocationExpression.Roles.Argument);
 
1941
                                        } else {
 
1942
                                                parent.AddChild ((MonoDevelop.CSharp.Ast.Expression)arg.Expr.Accept (this), InvocationExpression.Roles.Argument);
 
1943
                                        }
 
1944
                                        if (commaLocations != null && i > 0) {
 
1945
                                                int idx = commaLocations.Count - i;
 
1946
                                                if (idx >= 0)
 
1947
                                                        parent.AddChild (new CSharpTokenNode (Convert (commaLocations[idx]), 1), InvocationExpression.Roles.Comma);
 
1948
                                        }
1391
1949
                                }
 
1950
                                if (commaLocations != null && commaLocations.Count > args.Count)
 
1951
                                        parent.AddChild (new CSharpTokenNode (Convert (commaLocations[0]), 1), InvocationExpression.Roles.Comma);
1392
1952
                        }
1393
1953
                        
1394
1954
                        public override object Visit (Invocation invocationExpression)
1395
1955
                        {
1396
1956
                                var result = new InvocationExpression ();
1397
 
                                LocationDescriptor location = LocationStorage.Get (invocationExpression);
1398
 
                                result.AddChild ((INode)invocationExpression.Expr.Accept (this), InvocationExpression.Roles.TargetExpression);
1399
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), InvocationExpression.Roles.LPar);
 
1957
                                var location = LocationsBag.GetLocations (invocationExpression);
 
1958
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)invocationExpression.Expression.Accept (this), InvocationExpression.Roles.TargetExpression);
 
1959
                                if (location != null)
 
1960
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), InvocationExpression.Roles.LPar);
1400
1961
                                AddArguments (result, location, invocationExpression.Arguments);
1401
1962
                                
1402
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), InvocationExpression.Roles.RPar);
 
1963
                                if (location != null)
 
1964
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), InvocationExpression.Roles.RPar);
1403
1965
                                return result;
1404
1966
                        }
1405
1967
                        
1407
1969
                        {
1408
1970
                                var result = new ObjectCreateExpression ();
1409
1971
                                
1410
 
                                LocationDescriptor location = LocationStorage.Get (newExpression);
1411
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "new".Length), ObjectCreateExpression.Roles.Keyword);
1412
 
                                
1413
 
                                if (newExpression.NewType != null)
1414
 
                                        result.AddChild ((INode)newExpression.NewType.Accept (this), ObjectCreateExpression.Roles.ReturnType);
1415
 
                                
1416
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ObjectCreateExpression.Roles.LPar);
1417
 
                                AddArguments (result, location, newExpression.NewArguments);
1418
 
                                
1419
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ObjectCreateExpression.Roles.RPar);
1420
 
                                
1421
 
                                return result;
1422
 
                        }
 
1972
                                var location = LocationsBag.GetLocations (newExpression);
 
1973
                                result.AddChild (new CSharpTokenNode (Convert (newExpression.Location), "new".Length), ObjectCreateExpression.Roles.Keyword);
 
1974
                                
 
1975
                                if (newExpression.TypeRequested != null)
 
1976
                                        result.AddChild (ConvertToType (newExpression.TypeRequested), ObjectCreateExpression.Roles.Type);
 
1977
                                if (location != null)
 
1978
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ObjectCreateExpression.Roles.LPar);
 
1979
                                AddArguments (result, location, newExpression.Arguments);
 
1980
                                
 
1981
                                if (location != null)
 
1982
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ObjectCreateExpression.Roles.RPar);
 
1983
                                
 
1984
                                // TODO: Collection initializer ?
 
1985
                                
 
1986
                                return result;
 
1987
                        }
 
1988
                        
 
1989
                        
 
1990
                        public override object Visit (NewInitialize newInitializeExpression)
 
1991
                        {
 
1992
                                var result = new ObjectCreateExpression ();
 
1993
                                result.AddChild (new CSharpTokenNode (Convert (newInitializeExpression.Location), "new".Length), ObjectCreateExpression.Roles.Keyword);
 
1994
                                
 
1995
                                if (newInitializeExpression.TypeRequested != null)
 
1996
                                        result.AddChild (ConvertToType (newInitializeExpression.TypeRequested), ObjectCreateExpression.Roles.Type);
 
1997
                                
 
1998
                                var location = LocationsBag.GetLocations (newInitializeExpression);
 
1999
                                if (location != null)
 
2000
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ObjectCreateExpression.Roles.LPar);
 
2001
                                AddArguments (result, location, newInitializeExpression.Arguments);
 
2002
                                if (location != null)
 
2003
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ObjectCreateExpression.Roles.RPar);
 
2004
                                
 
2005
                                return result;
 
2006
                        }
 
2007
                        
1423
2008
                        
1424
2009
                        public override object Visit (ArrayCreation arrayCreationExpression)
1425
2010
                        {
1426
 
                                var result = new ArrayObjectCreateExpression ();
 
2011
                                var result = new ArrayCreateExpression ();
1427
2012
                                
1428
 
                                var location = LocationStorage.Get (arrayCreationExpression);
1429
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "new".Length), ArrayObjectCreateExpression.Roles.Keyword);
 
2013
                                var location = LocationsBag.GetLocations (arrayCreationExpression);
 
2014
                                result.AddChild (new CSharpTokenNode (Convert (arrayCreationExpression.Location), "new".Length), ArrayCreateExpression.Roles.Keyword);
1430
2015
                                
1431
2016
                                if (arrayCreationExpression.NewType != null)
1432
 
                                        result.AddChild ((INode)arrayCreationExpression.NewType.Accept (this), ArrayObjectCreateExpression.Roles.ReturnType);
1433
 
                                
1434
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ArrayObjectCreateExpression.Roles.LBracket);
 
2017
                                        result.AddChild (ConvertToType (arrayCreationExpression.NewType), ArrayCreateExpression.Roles.Type);
 
2018
                                if (location != null)
 
2019
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ArrayCreateExpression.Roles.LBracket);
1435
2020
                                if (arrayCreationExpression.Arguments != null) {
 
2021
                                        var commaLocations = LocationsBag.GetLocations (arrayCreationExpression.Arguments);
1436
2022
                                        for (int i = 0 ;i < arrayCreationExpression.Arguments.Count; i++) {
1437
 
                                                if (i > 0)
1438
 
                                                        result.AddChild (new CSharpTokenNode (Convert (location.LocationList [i - 1]), 1), IndexerExpression.Roles.Comma);
1439
 
                                                result.AddChild ((INode)arrayCreationExpression.Arguments[i].Accept (this), ObjectCreateExpression.Roles.Initializer);
 
2023
                                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)arrayCreationExpression.Arguments[i].Accept (this), ArrayCreateExpression.Roles.Argument);
 
2024
                                                if (commaLocations != null && i > 0)
 
2025
                                                        result.AddChild (new CSharpTokenNode (Convert (commaLocations [commaLocations.Count - i]), 1), ArrayCreateExpression.Roles.Comma);
1440
2026
                                        }
1441
2027
                                }
1442
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), ArrayObjectCreateExpression.Roles.RBracket);
 
2028
                                if (location != null)
 
2029
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ArrayCreateExpression.Roles.RBracket);
1443
2030
                                
1444
 
                                if (arrayCreationExpression.Initializers != null) {
1445
 
                                        var initLocation = LocationStorage.Get (arrayCreationExpression.Initializers);
1446
 
                                        result.AddChild (new CSharpTokenNode (Convert (initLocation[0]), 1), ArrayObjectCreateExpression.Roles.LBrace);
1447
 
                                        if (arrayCreationExpression.Initializers.Elements != null) {
1448
 
                                                for (int i = 0; i < arrayCreationExpression.Initializers.Elements.Count; i++) {
1449
 
                                                        if (i > 0)
1450
 
                                                                result.AddChild (new CSharpTokenNode (Convert (initLocation.LocationList [i - 1]), 1), IndexerExpression.Roles.Comma);
1451
 
                                                        result.AddChild ((INode)arrayCreationExpression.Initializers.Elements[i].Accept (this), ObjectCreateExpression.Roles.Initializer);
 
2031
                                if (arrayCreationExpression.Initializers != null && arrayCreationExpression.Initializers.Count != 0) {
 
2032
                                        //throw new NotImplementedException();
 
2033
                                        /* TODO: use ArrayInitializerExpression
 
2034
                                        var initLocation = LocationsBag.GetLocations (arrayCreationExpression.Initializers);
 
2035
                                        result.AddChild (new CSharpTokenNode (Convert (arrayCreationExpression.Initializers.Location), 1), ArrayCreateExpression.Roles.LBrace);
 
2036
                                        var commaLocations = LocationsBag.GetLocations (arrayCreationExpression.Initializers.Elements);
 
2037
                                        for (int i = 0; i < arrayCreationExpression.Initializers.Count; i++) {
 
2038
                                                result.AddChild ((AstNode)arrayCreationExpression.Initializers[i].Accept (this), ObjectCreateExpression.Roles.Variable);
 
2039
                                                if (commaLocations != null && i > 0) {
 
2040
                                                        result.AddChild (new CSharpTokenNode (Convert (commaLocations [commaLocations.Count - i]), 1), IndexerExpression.Roles.Comma);
1452
2041
                                                }
1453
2042
                                        }
1454
 
                                        result.AddChild (new CSharpTokenNode (Convert (initLocation[1]), 1), ArrayObjectCreateExpression.Roles.RBrace);
 
2043
                                        
 
2044
                                        if (initLocation != null)
 
2045
                                                result.AddChild (new CSharpTokenNode (Convert (initLocation[initLocation.Count - 1]), 1), ArrayCreateExpression.Roles.RBrace); */
1455
2046
                                }
1456
2047
                                
1457
2048
                                return result;
1476
2067
                        {
1477
2068
                                var result = new ArgListExpression ();
1478
2069
                                result.AddChild (new CSharpTokenNode (Convert (argListExpression.Location), "__arglist".Length), ArgListExpression.Roles.Keyword);
1479
 
                                LocationDescriptor location = LocationStorage.Get (argListExpression);
1480
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ArgListExpression.Roles.LPar);
 
2070
                                var location = LocationsBag.GetLocations (argListExpression);
 
2071
                                if (location != null)
 
2072
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ArgListExpression.Roles.LPar);
1481
2073
                                
1482
2074
                                AddArguments (result, location, argListExpression.Arguments);
1483
2075
                                
1484
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ArgListExpression.Roles.RPar);
 
2076
                                if (location != null)
 
2077
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ArgListExpression.Roles.RPar);
1485
2078
                                return result;
1486
2079
                        }
1487
2080
                        
1488
2081
                        public override object Visit (TypeOf typeOfExpression)
1489
2082
                        {
1490
2083
                                var result = new TypeOfExpression ();
1491
 
                                LocationDescriptor location = LocationStorage.Get (typeOfExpression);
 
2084
                                var location = LocationsBag.GetLocations (typeOfExpression);
1492
2085
                                result.AddChild (new CSharpTokenNode (Convert (typeOfExpression.Location), "typeof".Length), TypeOfExpression.Roles.Keyword);
1493
2086
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
1494
 
                                result.AddChild ((INode)typeOfExpression.QueriedType.Accept (this), TypeOfExpression.Roles.ReturnType);
 
2087
                                result.AddChild (ConvertToType (typeOfExpression.TypeExpression), TypeOfExpression.Roles.Type);
1495
2088
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
1496
2089
                                return result;
1497
2090
                        }
1499
2092
                        public override object Visit (SizeOf sizeOfExpression)
1500
2093
                        {
1501
2094
                                var result = new SizeOfExpression ();
1502
 
                                LocationDescriptor location = LocationStorage.Get (sizeOfExpression);
 
2095
                                var location = LocationsBag.GetLocations (sizeOfExpression);
1503
2096
                                result.AddChild (new CSharpTokenNode (Convert (sizeOfExpression.Location), "sizeof".Length), TypeOfExpression.Roles.Keyword);
1504
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
1505
 
                                result.AddChild ((INode)sizeOfExpression.QueriedType.Accept (this), TypeOfExpression.Roles.ReturnType);
1506
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
 
2097
                                if (location != null)
 
2098
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
 
2099
                                result.AddChild (ConvertToType (sizeOfExpression.QueriedType), TypeOfExpression.Roles.Type);
 
2100
                                if (location != null)
 
2101
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
1507
2102
                                return result;
1508
2103
                        }
1509
2104
                        
1510
2105
                        public override object Visit (CheckedExpr checkedExpression)
1511
2106
                        {
1512
2107
                                var result = new CheckedExpression ();
1513
 
                                LocationDescriptor location = LocationStorage.Get (checkedExpression);
 
2108
                                var location = LocationsBag.GetLocations (checkedExpression);
1514
2109
                                result.AddChild (new CSharpTokenNode (Convert (checkedExpression.Location), "checked".Length), TypeOfExpression.Roles.Keyword);
1515
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
1516
 
                                result.AddChild ((INode)checkedExpression.Expr.Accept (this), TypeOfExpression.Roles.Expression);
1517
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
 
2110
                                if (location != null)
 
2111
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
 
2112
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)checkedExpression.Expr.Accept (this), TypeOfExpression.Roles.Expression);
 
2113
                                if (location != null)
 
2114
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
1518
2115
                                return result;
1519
2116
                        }
1520
2117
                        
1521
2118
                        public override object Visit (UnCheckedExpr uncheckedExpression)
1522
2119
                        {
1523
2120
                                var result = new UncheckedExpression ();
1524
 
                                LocationDescriptor location = LocationStorage.Get (uncheckedExpression);
 
2121
                                var location = LocationsBag.GetLocations (uncheckedExpression);
1525
2122
                                result.AddChild (new CSharpTokenNode (Convert (uncheckedExpression.Location), "unchecked".Length), TypeOfExpression.Roles.Keyword);
1526
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
1527
 
                                result.AddChild ((INode)uncheckedExpression.Expr.Accept (this), TypeOfExpression.Roles.Expression);
1528
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
 
2123
                                if (location != null)
 
2124
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
 
2125
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)uncheckedExpression.Expr.Accept (this), TypeOfExpression.Roles.Expression);
 
2126
                                if (location != null)
 
2127
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
1529
2128
                                return result;
1530
2129
                        }
1531
2130
                        
1532
2131
                        public override object Visit (ElementAccess elementAccessExpression)
1533
2132
                        {
1534
2133
                                IndexerExpression result = new IndexerExpression ();
1535
 
                                LocationDescriptor location = LocationStorage.Get (elementAccessExpression);
1536
 
                                 
1537
 
                                result.AddChild ((INode)elementAccessExpression.Expr.Accept (this), IndexerExpression.Roles.TargetExpression);
1538
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LBracket);
 
2134
                                var location = LocationsBag.GetLocations (elementAccessExpression);
 
2135
                                
 
2136
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)elementAccessExpression.Expr.Accept (this), IndexerExpression.Roles.TargetExpression);
 
2137
                                result.AddChild (new CSharpTokenNode (Convert (elementAccessExpression.Location), 1), TypeOfExpression.Roles.LBracket);
1539
2138
                                AddArguments (result, location, elementAccessExpression.Arguments);
1540
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RBracket);
 
2139
                                if (location != null)
 
2140
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.RBracket);
1541
2141
                                return result;
1542
2142
                        }
1543
2143
                        
1544
 
                        public override object Visit (BaseAccess baseAccessExpression)
 
2144
                        public override object Visit (BaseThis baseAccessExpression)
1545
2145
                        {
1546
 
                                var result = new MemberReferenceExpression ();
1547
 
                                
1548
 
                                LocationDescriptor location = LocationStorage.Get (baseAccessExpression);
1549
 
                                
1550
 
                                BaseReferenceExpression baseReferenceExpression = new BaseReferenceExpression ();
1551
 
                                baseReferenceExpression.Location = Convert (location[0]);
1552
 
                                Console.WriteLine (baseReferenceExpression.Location);
1553
 
                                result.AddChild (baseReferenceExpression, MemberReferenceExpression.Roles.TargetExpression);
1554
 
                                
1555
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MemberReferenceExpression.Roles.Dot);
1556
 
                                result.AddChild (new Identifier (baseAccessExpression.Identifier, Convert (location[2])), MemberReferenceExpression.Roles.Identifier);
1557
 
                                
 
2146
                                var result = new BaseReferenceExpression ();
 
2147
                                result.Location = Convert (baseAccessExpression.Location);
1558
2148
                                return result;
1559
2149
                        }
1560
2150
                        
1562
2152
                        {
1563
2153
                                var result = new StackAllocExpression ();
1564
2154
                                
1565
 
                                LocationDescriptor location = LocationStorage.Get (stackAllocExpression);
1566
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "stackalloc".Length), StackAllocExpression.StackAllocKeywordRole);
1567
 
                                result.AddChild ((INode)stackAllocExpression.TypeExpression.Accept (this), StackAllocExpression.Roles.ReturnType);
1568
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), StackAllocExpression.Roles.LBracket);
1569
 
                                result.AddChild ((INode)stackAllocExpression.CountExpression.Accept (this), StackAllocExpression.Roles.Expression);
1570
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), StackAllocExpression.Roles.RBracket);
 
2155
                                var location = LocationsBag.GetLocations (stackAllocExpression);
 
2156
                                if (location != null)
 
2157
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "stackalloc".Length), StackAllocExpression.Roles.Keyword);
 
2158
                                result.AddChild (ConvertToType (stackAllocExpression.TypeExpression), StackAllocExpression.Roles.Type);
 
2159
                                if (location != null && location.Count > 1)
 
2160
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), StackAllocExpression.Roles.LBracket);
 
2161
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)stackAllocExpression.CountExpression.Accept (this), StackAllocExpression.Roles.Expression);
 
2162
                                if (location != null && location.Count > 2)
 
2163
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), StackAllocExpression.Roles.RBracket);
1571
2164
                                return result;
1572
2165
                        }
1573
2166
                        
1575
2168
                        {
1576
2169
                                var result = new AssignmentExpression ();
1577
2170
                                
1578
 
                                LocationDescriptor location = LocationStorage.Get (simpleAssign);
1579
 
                                
1580
 
                                result.AssignmentOperatorType = AssignmentOperatorType.Assign;
 
2171
                                result.Operator = AssignmentOperatorType.Assign;
1581
2172
                                if (simpleAssign.Target != null)
1582
 
                                        result.AddChild ((INode)simpleAssign.Target.Accept (this), AssignmentExpression.LeftExpressionRole);
1583
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), AssignmentExpression.OperatorRole);
 
2173
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)simpleAssign.Target.Accept (this), AssignmentExpression.LeftRole);
 
2174
                                result.AddChild (new CSharpTokenNode (Convert (simpleAssign.Location), 1), AssignmentExpression.OperatorRole);
1584
2175
                                
1585
 
                                if (simpleAssign.Source != null)
1586
 
                                        result.AddChild ((INode)simpleAssign.Source.Accept (this), AssignmentExpression.RightExpressionRole);
 
2176
                                if (simpleAssign.Source != null) {
 
2177
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)simpleAssign.Source.Accept (this), AssignmentExpression.RightRole);
 
2178
                                }
1587
2179
                                return result;
1588
2180
                        }
1589
2181
                        
1590
2182
                        public override object Visit (CompoundAssign compoundAssign)
1591
2183
                        {
1592
2184
                                var result = new AssignmentExpression ();
1593
 
                                LocationDescriptor location = LocationStorage.Get (compoundAssign);
1594
2185
                                int opLength = 2;
1595
2186
                                switch (compoundAssign.Op) {
1596
 
                                case Binary.Operator.Multiply:
1597
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.Multiply;
1598
 
                                        break;
1599
 
                                case Binary.Operator.Division:
1600
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.Divide;
1601
 
                                        break;
1602
 
                                case Binary.Operator.Modulus:
1603
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.Modulus;
1604
 
                                        break;
1605
 
                                case Binary.Operator.Addition:
1606
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.Add;
1607
 
                                        break;
1608
 
                                case Binary.Operator.Subtraction:
1609
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.Subtract;
1610
 
                                        break;
1611
 
                                case Binary.Operator.LeftShift:
1612
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.ShiftLeft;
1613
 
                                        opLength = 3;
1614
 
                                        break;
1615
 
                                case Binary.Operator.RightShift:
1616
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.ShiftRight;
1617
 
                                        opLength = 3;
1618
 
                                        break;
1619
 
                                case Binary.Operator.BitwiseAnd:
1620
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.BitwiseAnd;
1621
 
                                        break;
1622
 
                                case Binary.Operator.BitwiseOr:
1623
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.BitwiseOr;
1624
 
                                        break;
1625
 
                                case Binary.Operator.ExclusiveOr:
1626
 
                                        result.AssignmentOperatorType = AssignmentOperatorType.ExclusiveOr;
1627
 
                                        break;
 
2187
                                        case Binary.Operator.Multiply:
 
2188
                                                result.Operator = AssignmentOperatorType.Multiply;
 
2189
                                                break;
 
2190
                                        case Binary.Operator.Division:
 
2191
                                                result.Operator = AssignmentOperatorType.Divide;
 
2192
                                                break;
 
2193
                                        case Binary.Operator.Modulus:
 
2194
                                                result.Operator = AssignmentOperatorType.Modulus;
 
2195
                                                break;
 
2196
                                        case Binary.Operator.Addition:
 
2197
                                                result.Operator = AssignmentOperatorType.Add;
 
2198
                                                break;
 
2199
                                        case Binary.Operator.Subtraction:
 
2200
                                                result.Operator = AssignmentOperatorType.Subtract;
 
2201
                                                break;
 
2202
                                        case Binary.Operator.LeftShift:
 
2203
                                                result.Operator = AssignmentOperatorType.ShiftLeft;
 
2204
                                                opLength = 3;
 
2205
                                                break;
 
2206
                                        case Binary.Operator.RightShift:
 
2207
                                                result.Operator = AssignmentOperatorType.ShiftRight;
 
2208
                                                opLength = 3;
 
2209
                                                break;
 
2210
                                        case Binary.Operator.BitwiseAnd:
 
2211
                                                result.Operator = AssignmentOperatorType.BitwiseAnd;
 
2212
                                                break;
 
2213
                                        case Binary.Operator.BitwiseOr:
 
2214
                                                result.Operator = AssignmentOperatorType.BitwiseOr;
 
2215
                                                break;
 
2216
                                        case Binary.Operator.ExclusiveOr:
 
2217
                                                result.Operator = AssignmentOperatorType.ExclusiveOr;
 
2218
                                                break;
1628
2219
                                }
1629
2220
                                
1630
 
                                result.AddChild ((INode)compoundAssign.Target.Accept (this), AssignmentExpression.LeftExpressionRole);
1631
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), opLength), AssignmentExpression.OperatorRole);
1632
 
                                result.AddChild ((INode)compoundAssign.Source.Accept (this), AssignmentExpression.RightExpressionRole);
 
2221
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)compoundAssign.Target.Accept (this), AssignmentExpression.LeftRole);
 
2222
                                result.AddChild (new CSharpTokenNode (Convert (compoundAssign.Location), opLength), AssignmentExpression.OperatorRole);
 
2223
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)compoundAssign.Source.Accept (this), AssignmentExpression.RightRole);
1633
2224
                                return result;
1634
2225
                        }
1635
2226
                        
1636
2227
                        public override object Visit (Mono.CSharp.AnonymousMethodExpression anonymousMethodExpression)
1637
2228
                        {
1638
 
                                var result = new MonoDevelop.CSharp.Dom.AnonymousMethodExpression ();
1639
 
                                LocationDescriptor location = LocationStorage.Get (anonymousMethodExpression);
1640
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "delegate".Length), AssignmentExpression.Roles.Keyword);
 
2229
                                var result = new MonoDevelop.CSharp.Ast.AnonymousMethodExpression ();
 
2230
                                var location = LocationsBag.GetLocations (anonymousMethodExpression);
 
2231
                                if (location != null) {
 
2232
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "delegate".Length), AssignmentExpression.Roles.Keyword);
 
2233
                                        
 
2234
                                        if (location.Count > 1) {
 
2235
                                                result.HasParameterList = true;
 
2236
                                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AssignmentExpression.Roles.LPar);
 
2237
                                                AddParameter (result, anonymousMethodExpression.Parameters);
 
2238
                                                result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AssignmentExpression.Roles.RPar);
 
2239
                                        }
 
2240
                                }
1641
2241
                                
1642
 
                                if (location.Keywords.Length > 1) {
1643
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AssignmentExpression.Roles.LPar);
1644
 
                                        AddParameter (result, anonymousMethodExpression.Parameters);
1645
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AssignmentExpression.Roles.RPar);
1646
 
                                }
1647
 
                                result.AddChild ((INode)anonymousMethodExpression.Block.Accept (this), AssignmentExpression.Roles.Body);
 
2242
                                result.AddChild ((BlockStatement)anonymousMethodExpression.Block.Accept (this), AssignmentExpression.Roles.Body);
1648
2243
                                return result;
1649
2244
                        }
1650
2245
 
1651
2246
                        public override object Visit (Mono.CSharp.LambdaExpression lambdaExpression)
1652
2247
                        {
1653
 
                                var result = new MonoDevelop.CSharp.Dom.LambdaExpression ();
1654
 
                                LocationDescriptor location = LocationStorage.Get (lambdaExpression);
1655
 
                                
1656
 
                                if (location.Keywords == null || location.Keywords.Length == 1) {
1657
 
                                        AddParameter (result, lambdaExpression.Parameters);
1658
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "=>".Length), AssignmentExpression.Roles.Assign);
1659
 
                                } else {
1660
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AssignmentExpression.Roles.LPar);
1661
 
                                        AddParameter (result, lambdaExpression.Parameters);
1662
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AssignmentExpression.Roles.RPar);
1663
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "=>".Length), AssignmentExpression.Roles.Assign);
1664
 
                                }
1665
 
                                if (lambdaExpression.Block.IsGenerated) {
1666
 
                                        ContextualReturn generatedReturn = (ContextualReturn)lambdaExpression.Block.Statements[0];
1667
 
                                        result.AddChild ((INode)generatedReturn.Expr.Accept (this), AssignmentExpression.Roles.Expression);
1668
 
                                } else {
1669
 
                                        result.AddChild ((INode)lambdaExpression.Block.Accept (this), AssignmentExpression.Roles.Expression);
1670
 
                                }
1671
 
                                
1672
 
                                return result;
1673
 
                        }
 
2248
                                var result = new MonoDevelop.CSharp.Ast.LambdaExpression ();
 
2249
                                var location = LocationsBag.GetLocations (lambdaExpression);
 
2250
                                
 
2251
                                if (location == null || location.Count == 1) {
 
2252
                                        AddParameter (result, lambdaExpression.Parameters);
 
2253
                                        if (location != null)
 
2254
                                                result.AddChild (new CSharpTokenNode (Convert (location [0]), "=>".Length), MonoDevelop.CSharp.Ast.LambdaExpression.ArrowRole);
 
2255
                                } else {
 
2256
                                        result.AddChild (new CSharpTokenNode (Convert (lambdaExpression.Location), 1), MonoDevelop.CSharp.Ast.LambdaExpression.Roles.LPar);
 
2257
                                        AddParameter (result, lambdaExpression.Parameters);
 
2258
                                        if (location != null) {
 
2259
                                                result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), MonoDevelop.CSharp.Ast.LambdaExpression.Roles.RPar);
 
2260
                                                result.AddChild (new CSharpTokenNode (Convert (location [1]), "=>".Length), MonoDevelop.CSharp.Ast.LambdaExpression.ArrowRole);
 
2261
                                        }
 
2262
                                }
 
2263
                                if (lambdaExpression.Block.IsCompilerGenerated) {
 
2264
                                        ContextualReturn generatedReturn = (ContextualReturn)lambdaExpression.Block.Statements [0];
 
2265
                                        result.AddChild ((AstNode)generatedReturn.Expr.Accept (this), MonoDevelop.CSharp.Ast.LambdaExpression.BodyRole);
 
2266
                                } else {
 
2267
                                        result.AddChild ((AstNode)lambdaExpression.Block.Accept (this), MonoDevelop.CSharp.Ast.LambdaExpression.BodyRole);
 
2268
                                }
 
2269
                                
 
2270
                                return result;
 
2271
                        }
 
2272
                        
 
2273
                        public override object Visit (ConstInitializer constInitializer)
 
2274
                        {
 
2275
                                return constInitializer.Expr.Accept (this);
 
2276
                        }
 
2277
                        
 
2278
                        public override object Visit (ArrayInitializer arrayInitializer)
 
2279
                        {
 
2280
                                var result = new ArrayInitializerExpression ();
 
2281
                                var location = LocationsBag.GetLocations (arrayInitializer);
 
2282
                                result.AddChild (new CSharpTokenNode (Convert (arrayInitializer.Location), "{".Length), ArrayInitializerExpression.Roles.LBrace);
 
2283
                                var commaLocations = LocationsBag.GetLocations (arrayInitializer.Elements);
 
2284
                                for (int i = 0; i < arrayInitializer.Count; i++) {
 
2285
                                        result.AddChild ((MonoDevelop.CSharp.Ast.Expression)arrayInitializer[i].Accept (this), ArrayInitializerExpression.Roles.Expression);
 
2286
                                        if (commaLocations != null && i < commaLocations.Count)
 
2287
                                                result.AddChild (new CSharpTokenNode (Convert (commaLocations[i]), ",".Length), ArrayInitializerExpression.Roles.Comma);
 
2288
                                }
 
2289
                                
 
2290
                                if (location != null) {
 
2291
                                        if (location.Count == 2) // optional comma
 
2292
                                                result.AddChild (new CSharpTokenNode (Convert (location[1]), ",".Length), ArrayInitializerExpression.Roles.Comma);
 
2293
                                        result.AddChild (new CSharpTokenNode (Convert (location[location.Count - 1]), "}".Length), ArrayInitializerExpression.Roles.RBrace);
 
2294
                                }
 
2295
                                return result;
 
2296
                        }
 
2297
                        
1674
2298
                        #endregion
1675
2299
                        
1676
2300
                        #region LINQ expressions
1677
 
                        public override object Visit (Mono.CSharp.Linq.QueryExpression queryExpression)
 
2301
/*                      public override object Visit (Mono.CSharp.Linq.Query queryExpression)
1678
2302
                        {
1679
 
                                var result = new QueryExpressionFromClause ();
1680
 
                                LocationDescriptor location = LocationStorage.Get (queryExpression);
1681
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "from".Length), QueryExpressionFromClause.FromKeywordRole);
 
2303
                                var result = new QueryFromClause ();
 
2304
                                var location = LocationsBag.GetLocations (queryExpression);
 
2305
                                if (location != null)
 
2306
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "from".Length), QueryFromClause.FromKeywordRole);
1682
2307
                                // TODO: select identifier
1683
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), QueryExpressionFromClause.InKeywordRole);
1684
 
                                result.AddChild ((INode)((Mono.CSharp.Linq.AQueryClause)queryExpression.Expr).Expr.Accept (this), QueryExpressionFromClause.Roles.Expression);
 
2308
                                if (location != null)
 
2309
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), QueryFromClause.InKeywordRole);
 
2310
                                var query = queryExpression.Expr as Mono.CSharp.Linq.AQueryClause;
 
2311
//                              if (query != null && query.Expr != null)
 
2312
//                                      result.AddChild ((AstNode)query.Expr.Accept (this), QueryFromClause.Roles.Expression);
1685
2313
                                return result;
1686
 
                        }
 
2314
                        }                                */
1687
2315
                        
1688
2316
                        public override object Visit (Mono.CSharp.Linq.SelectMany selectMany)
1689
2317
                        {
1690
 
                                var result = new QueryExpressionFromClause ();
1691
 
                                Mono.CSharp.Linq.Cast cast = selectMany.Expr as Mono.CSharp.Linq.Cast;
1692
 
                                LocationDescriptor location = LocationStorage.Get (selectMany);
1693
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "from".Length), QueryExpressionFromClause.FromKeywordRole);
1694
 
                                
1695
 
                                if (cast != null)
1696
 
                                        result.AddChild ((INode)cast.TypeExpr.Accept (this), QueryExpressionFromClause.Roles.ReturnType);
1697
 
                                
1698
 
                                result.AddChild (new Identifier (selectMany.SelectIdentifier.Value, Convert (selectMany.SelectIdentifier.Location)), QueryExpressionFromClause.Roles.Identifier);
1699
 
                                
1700
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), QueryExpressionFromClause.InKeywordRole);
1701
 
                                
1702
 
                                result.AddChild ((INode)(cast != null ? cast.Expr : selectMany.Expr).Accept (this), QueryExpressionFromClause.Roles.Expression);
 
2318
                                var result = new QueryFromClause ();
 
2319
                                // TODO:
 
2320
//                              Mono.CSharp.Linq.Cast cast = selectMany.Expr as Mono.CSharp.Linq.Cast;
 
2321
                                var location = LocationsBag.GetLocations (selectMany);
 
2322
                                if (location != null)
 
2323
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "from".Length), QueryFromClause.FromKeywordRole);
 
2324
                                
 
2325
                                //                                      result.AddChild ((AstNode)cast.TypeExpr.Accept (this), QueryFromClause.Roles.ReturnType);
 
2326
//                              if (cast != null)
 
2327
                                
 
2328
//                              result.AddChild (CreateIdentifier (selectMany.SelectIdentifier.Value, Convert (selectMany.SelectIdentifier.Location)), QueryFromClause.Roles.Identifier);
 
2329
                                //                              result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), QueryFromClause.InKeywordRole);
 
2330
                                
 
2331
                                //                              result.AddChild ((AstNode)(cast != null ? cast.Expr : selectMany.Expr).Accept (this), QueryFromClause.Roles.Expression);
 
2332
                                
1703
2333
                                
1704
2334
                                return result;
1705
2335
                        }
1706
2336
                        
1707
2337
                        public override object Visit (Mono.CSharp.Linq.Select sel)
1708
2338
                        {
1709
 
                                var result = new QueryExpressionSelectClause ();
1710
 
                                LocationDescriptor location = LocationStorage.Get (sel);
1711
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "select".Length), QueryExpressionWhereClause.Roles.Keyword);
1712
 
                                result.AddChild ((INode)sel.Expr.Accept (this), QueryExpressionWhereClause.Roles.Expression);
 
2339
                                var result = new QuerySelectClause ();
 
2340
                                var location = LocationsBag.GetLocations (sel);
 
2341
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "select".Length), QueryWhereClause.Roles.Keyword);
 
2342
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)sel.Expr.Accept (this), QueryWhereClause.Roles.Expression);
1713
2343
                                return result;
1714
2344
                        }
1715
2345
                        
1716
2346
                        public override object Visit (Mono.CSharp.Linq.GroupBy groupBy)
1717
2347
                        {
1718
 
                                var result = new QueryExpressionGroupClause ();
1719
 
                                LocationDescriptor location = LocationStorage.Get (groupBy);
1720
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "group".Length), QueryExpressionGroupClause.GroupKeywordRole);
1721
 
                                result.AddChild ((INode)groupBy.ElementSelector.Accept (this), QueryExpressionGroupClause.GroupByExpressionRole);
1722
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "by".Length), QueryExpressionGroupClause.ByKeywordRole);
1723
 
                                result.AddChild ((INode)groupBy.Expr.Accept (this), QueryExpressionGroupClause.ProjectionExpressionRole);
 
2348
                                var result = new QueryGroupClause ();
 
2349
                                var location = LocationsBag.GetLocations (groupBy);
 
2350
                                if (location != null)
 
2351
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "group".Length), QueryGroupClause.GroupKeywordRole);
 
2352
//                              result.AddChild ((AstNode)groupBy.ElementSelector.Accept (this), QueryGroupClause.GroupByExpressionRole);
 
2353
//                              if (location != null)
 
2354
//                                      result.AddChild (new CSharpTokenNode (Convert (location[1]), "by".Length), QueryGroupClause.ByKeywordRole);
 
2355
//                              result.AddChild ((AstNode)groupBy.Expr.Accept (this), QueryGroupClause.ProjectionExpressionRole);
1724
2356
                                return result;
1725
2357
                        }
1726
2358
                        
1727
2359
                        public override object Visit (Mono.CSharp.Linq.Let l)
1728
2360
                        {
1729
 
                                var result = new QueryExpressionLetClause ();
1730
 
                                LocationDescriptor location = LocationStorage.Get (l);
 
2361
                                var result = new QueryLetClause ();
 
2362
                                var location = LocationsBag.GetLocations (l);
1731
2363
                                
1732
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "let".Length), QueryExpressionWhereClause.Roles.Keyword);
 
2364
                                if (location != null)
 
2365
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "let".Length), QueryWhereClause.Roles.Keyword);
1733
2366
                                
1734
2367
                                NewAnonymousType aType = l.Expr as NewAnonymousType;
1735
2368
                                AnonymousTypeParameter param = ((AnonymousTypeParameter)aType.Parameters[1]);
1736
 
                                result.AddChild (new Identifier (param.Name, Convert (param.Location)));
1737
 
                                
1738
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), QueryExpressionWhereClause.Roles.Assign);
1739
 
                                
1740
 
                                result.AddChild ((INode)param.Expr.Accept (this), QueryExpressionWhereClause.Roles.Condition);
 
2369
                                result.AddChild (CreateIdentifier (param.Name, Convert (param.Location)), Identifier.Roles.Identifier);
 
2370
                                
 
2371
                                if (location != null)
 
2372
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), QueryWhereClause.Roles.Assign);
 
2373
                                
 
2374
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)param.Expr.Accept (this), QueryWhereClause.Roles.Condition);
1741
2375
                                return result;
1742
2376
                        }
1743
2377
                        
1744
2378
                        public override object Visit (Mono.CSharp.Linq.Where w)
1745
2379
                        {
1746
 
                                var result = new QueryExpressionWhereClause ();
1747
 
                                LocationDescriptor location = LocationStorage.Get (w);
1748
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "where".Length), QueryExpressionWhereClause.Roles.Keyword);
1749
 
                                result.AddChild ((INode)w.Expr.Accept (this), QueryExpressionWhereClause.Roles.Condition);
 
2380
                                var result = new QueryWhereClause ();
 
2381
                                var location = LocationsBag.GetLocations (w);
 
2382
                                if (location != null)
 
2383
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "where".Length), QueryWhereClause.Roles.Keyword);
 
2384
                                result.AddChild ((MonoDevelop.CSharp.Ast.Expression)w.Expr.Accept (this), QueryWhereClause.Roles.Condition);
1750
2385
                                return result;
1751
2386
                        }
1752
2387
                        
1753
2388
                        public override object Visit (Mono.CSharp.Linq.Join join)
1754
2389
                        {
1755
 
                                var result = new QueryExpressionJoinClause ();
1756
 
                                LocationDescriptor location = LocationStorage.Get (join);
1757
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "join".Length), QueryExpressionJoinClause.JoinKeywordRole);
1758
 
                                
1759
 
                                result.AddChild (new Identifier (join.JoinIdentifier.Value, Convert (join.JoinIdentifier.Location)));
1760
 
                                
1761
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), QueryExpressionJoinClause.InKeywordRole);
1762
 
                                
1763
 
                                result.AddChild ((INode)join.Expr.Accept (this), QueryExpressionJoinClause.Roles.Expression);
1764
 
                                
1765
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "on".Length), QueryExpressionJoinClause.OnKeywordRole);
 
2390
                                var result = new QueryJoinClause ();
 
2391
                /*              var location = LocationsBag.GetLocations (join);
 
2392
                                if (location != null)
 
2393
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "join".Length), QueryJoinClause.JoinKeywordRole);
 
2394
                                
 
2395
                                result.AddChild (CreateIdentifier (join.JoinVariable.Name, Convert (join.JoinVariable.Location)), Identifier.Roles.Identifier);
 
2396
                                
 
2397
                                if (location != null)
 
2398
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), QueryJoinClause.InKeywordRole);
 
2399
                                
 
2400
                                result.AddChild ((AstNode)join.Expr.Accept (this), QueryJoinClause.Roles.Expression);
 
2401
                                
 
2402
                                if (location != null)
 
2403
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), "on".Length), QueryJoinClause.OnKeywordRole);
1766
2404
                                // TODO: on expression
1767
2405
                                
1768
 
                                result.AddChild (new CSharpTokenNode (Convert (location[3]), "equals".Length), QueryExpressionJoinClause.EqualsKeywordRole);
 
2406
                                if (location != null)
 
2407
                                        result.AddChild (new CSharpTokenNode (Convert (location[3]), "equals".Length), QueryJoinClause.EqualsKeywordRole);
1769
2408
                                // TODO: equals expression
1770
 
                                
 
2409
                                */
1771
2410
                                return result;
1772
2411
                        }
1773
2412
                        
1774
2413
                        public override object Visit (Mono.CSharp.Linq.GroupJoin groupJoin)
1775
2414
                        {
1776
 
                                var result = new QueryExpressionJoinClause ();
1777
 
                                LocationDescriptor location = LocationStorage.Get (groupJoin);
1778
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "join".Length), QueryExpressionJoinClause.JoinKeywordRole);
1779
 
                                
1780
 
                                result.AddChild (new Identifier (groupJoin.JoinIdentifier.Value, Convert (groupJoin.JoinIdentifier.Location)));
1781
 
                                
1782
 
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), QueryExpressionJoinClause.InKeywordRole);
1783
 
                                
1784
 
                                result.AddChild ((INode)groupJoin.Expr.Accept (this), QueryExpressionJoinClause.Roles.Expression);
1785
 
                                
1786
 
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "on".Length), QueryExpressionJoinClause.OnKeywordRole);
 
2415
                                var result = new QueryJoinClause ();
 
2416
/*                              var location = LocationsBag.GetLocations (groupJoin);
 
2417
                                if (location != null)
 
2418
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "join".Length), QueryJoinClause.JoinKeywordRole);
 
2419
                                
 
2420
                                result.AddChild (CreateIdentifier (groupJoin.JoinVariable.Name, Convert (groupJoin.JoinVariable.Location)), Identifier.Roles.Identifier);
 
2421
                                
 
2422
                                if (location != null)
 
2423
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), QueryJoinClause.InKeywordRole);
 
2424
                                
 
2425
                                result.AddChild ((AstNode)groupJoin.Expr.Accept (this), QueryJoinClause.Roles.Expression);
 
2426
                                
 
2427
                                if (location != null)
 
2428
                                        result.AddChild (new CSharpTokenNode (Convert (location[2]), "on".Length), QueryJoinClause.OnKeywordRole);
1787
2429
                                // TODO: on expression
1788
2430
                                
1789
 
                                result.AddChild (new CSharpTokenNode (Convert (location[3]), "equals".Length), QueryExpressionJoinClause.EqualsKeywordRole);
 
2431
                                if (location != null)
 
2432
                                        result.AddChild (new CSharpTokenNode (Convert (location[3]), "equals".Length), QueryJoinClause.EqualsKeywordRole);
1790
2433
                                // TODO: equals expression
1791
2434
                                
1792
 
                                result.AddChild (new CSharpTokenNode (Convert (location[4]), "into".Length), QueryExpressionJoinClause.IntoKeywordRole);
 
2435
                                if (location != null)
 
2436
                                        result.AddChild (new CSharpTokenNode (Convert (location[4]), "into".Length), QueryJoinClause.IntoKeywordRole);
1793
2437
                                
1794
 
                                result.AddChild (new Identifier (groupJoin.IntoVariable.Value, Convert (groupJoin.IntoVariable.Location)));
 
2438
                                result.AddChild (CreateIdentifier (groupJoin.JoinVariable.Name, Convert (groupJoin.JoinVariable.Location)), Identifier.Roles.Identifier);*/
1795
2439
                                return result;
1796
2440
                        }
1797
2441
                        
1798
2442
                        public override object Visit (Mono.CSharp.Linq.OrderByAscending orderByAscending)
1799
2443
                        {
1800
 
                                var result = new QueryExpressionOrderClause ();
1801
 
                                result.OrderAscending = true;
1802
 
                                result.AddChild ((INode)orderByAscending.Expr.Accept (this), QueryExpressionWhereClause.Roles.Expression);
1803
 
                                LocationDescriptor location = LocationStorage.Get (orderByAscending);
1804
 
                                if (location.Keywords != null) 
1805
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "ascending".Length), QueryExpressionWhereClause.Roles.Keyword);
 
2444
                                var result = new QueryOrderClause ();
 
2445
                        /*      result.OrderAscending = true;
 
2446
                                result.AddChild ((AstNode)orderByAscending.Expr.Accept (this), QueryWhereClause.Roles.Expression);
 
2447
                                var location = LocationsBag.GetLocations (orderByAscending);
 
2448
                                if (location != null)
 
2449
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "ascending".Length), QueryWhereClause.Roles.Keyword);*/
1806
2450
                                return result;
1807
2451
                        }
1808
2452
                        
1809
2453
                        public override object Visit (Mono.CSharp.Linq.OrderByDescending orderByDescending)
1810
2454
                        {
1811
 
                                var result = new QueryExpressionOrderClause ();
1812
 
                                result.OrderAscending = false;
1813
 
                                result.AddChild ((INode)orderByDescending.Expr.Accept (this), QueryExpressionWhereClause.Roles.Expression);
1814
 
                                LocationDescriptor location = LocationStorage.Get (orderByDescending);
1815
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "descending".Length), QueryExpressionWhereClause.Roles.Keyword);
 
2455
                                var result = new QueryOrderClause ();
 
2456
                /*              result.OrderAscending = false;
 
2457
                                result.AddChild ((AstNode)orderByDescending.Expr.Accept (this), QueryWhereClause.Roles.Expression);
 
2458
                                var location = LocationsBag.GetLocations (orderByDescending);
 
2459
                                if (location != null)
 
2460
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "descending".Length), QueryWhereClause.Roles.Keyword);*/
1816
2461
                                return result;
1817
2462
                        }
1818
2463
                        
1819
2464
                        public override object Visit (Mono.CSharp.Linq.ThenByAscending thenByAscending)
1820
2465
                        {
1821
 
                                var result = new QueryExpressionOrderClause ();
1822
 
                                result.OrderAscending = true;
1823
 
                                result.AddChild ((INode)thenByAscending.Expr.Accept (this), QueryExpressionWhereClause.Roles.Expression);
1824
 
                                LocationDescriptor location = LocationStorage.Get (thenByAscending);
1825
 
                                if (location.Keywords != null) 
1826
 
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "ascending".Length), QueryExpressionWhereClause.Roles.Keyword);
 
2466
                                var result = new QueryOrderClause ();
 
2467
                        /*      result.OrderAscending = true;
 
2468
                                result.AddChild ((AstNode)thenByAscending.Expr.Accept (this), QueryWhereClause.Roles.Expression);
 
2469
                                var location = LocationsBag.GetLocations (thenByAscending);
 
2470
                                if (location != null)
 
2471
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "ascending".Length), QueryWhereClause.Roles.Keyword);*/
1827
2472
                                return result;
1828
2473
                        }
1829
2474
                        
1830
2475
                        public override object Visit (Mono.CSharp.Linq.ThenByDescending thenByDescending)
1831
2476
                        {
1832
 
                                var result = new QueryExpressionOrderClause ();
1833
 
                                result.OrderAscending = false;
1834
 
                                result.AddChild ((INode)thenByDescending.Expr.Accept (this), QueryExpressionWhereClause.Roles.Expression);
1835
 
                                LocationDescriptor location = LocationStorage.Get (thenByDescending);
1836
 
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "descending".Length), QueryExpressionWhereClause.Roles.Keyword);
 
2477
                                var result = new QueryOrderClause ();
 
2478
/*                              result.OrderAscending = false;
 
2479
                                result.AddChild ((AstNode)thenByDescending.Expr.Accept (this), QueryWhereClause.Roles.Expression);
 
2480
                                var location = LocationsBag.GetLocations (thenByDescending);
 
2481
                                if (location != null)
 
2482
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), "descending".Length), QueryWhereClause.Roles.Keyword);*/
1837
2483
                                return result;
1838
2484
                        }
1839
2485
                        #endregion
1840
2486
                }
1841
2487
 
1842
 
                public MonoDevelop.CSharp.Dom.CompilationUnit Parse (TextEditorData data)
1843
 
                {
1844
 
                        Tokenizer.InterpretTabAsSingleChar = true;
1845
 
                        CompilerCompilationUnit top;
1846
 
                        using (Stream stream = data.OpenStream ()) {
1847
 
                                top = CompilerCallableEntryPoint.ParseFile (new string[] { "-v", "-unsafe"}, stream, data.Document.FileName, Console.Out);
1848
 
                        }
1849
 
 
 
2488
                public static void InsertComment (AstNode node, MonoDevelop.CSharp.Ast.Comment comment)
 
2489
                {
 
2490
                        if (node.EndLocation < comment.StartLocation) {
 
2491
                                node.AddChild (comment, AstNode.Roles.Comment);
 
2492
                                return;
 
2493
                        }
 
2494
                        
 
2495
                        foreach (var child in node.Children) {
 
2496
                                if (child.StartLocation < comment.StartLocation && comment.StartLocation < child.EndLocation) {
 
2497
                                        InsertComment (child, comment);
 
2498
                                        return;
 
2499
                                }
 
2500
                                if (comment.StartLocation < child.StartLocation) {
 
2501
                                        node.InsertChildBefore (child, comment, AstNode.Roles.Comment);
 
2502
                                        return;
 
2503
                                }
 
2504
                        }
 
2505
                        
 
2506
                        node.AddChild (comment, AstNode.Roles.Comment);
 
2507
                }
 
2508
                
 
2509
                static void InsertComments (CompilerCompilationUnit top, ConversionVisitor conversionVisitor)
 
2510
                {
 
2511
                        foreach (var special in top.SpecialsBag.Specials) {
 
2512
                                var comment = special as SpecialsBag.Comment;
 
2513
                                
 
2514
                                if (comment != null) {
 
2515
                                        var type = (MonoDevelop.CSharp.Ast.CommentType)comment.CommentType;
 
2516
                                        var start = new AstLocation (comment.Line, comment.Col);
 
2517
                                        var end = new AstLocation (comment.EndLine, comment.EndCol);
 
2518
                                        var domComment = new MonoDevelop.CSharp.Ast.Comment (type, start, end);
 
2519
                                        domComment.StartsLine = comment.StartsLine;
 
2520
                                        domComment.Content = comment.Content;
 
2521
                                        InsertComment (conversionVisitor.Unit, domComment);
 
2522
                                }
 
2523
                        }
 
2524
                }
 
2525
                
 
2526
                internal static MonoDevelop.CSharp.Ast.CompilationUnit Parse (CompilerCompilationUnit top)
 
2527
                {
1850
2528
                        if (top == null)
1851
2529
                                return null;
1852
 
                        CSharpParser.ConversionVisitor conversionVisitor = new ConversionVisitor (top.LocationStorage);
1853
 
                        top.ModuleCompiled.Accept (conversionVisitor);
 
2530
                        CSharpParser.ConversionVisitor conversionVisitor = new ConversionVisitor (top.LocationsBag);
 
2531
                        top.UsingsBag.Global.Accept (conversionVisitor);
 
2532
                        InsertComments (top, conversionVisitor);
1854
2533
                        return conversionVisitor.Unit;
1855
2534
                }
 
2535
 
 
2536
                McsParser.ErrorReportPrinter errorReportPrinter = new McsParser.ErrorReportPrinter ();
 
2537
                
 
2538
                public McsParser.ErrorReportPrinter ErrorReportPrinter {
 
2539
                        get {
 
2540
                                return errorReportPrinter;
 
2541
                        }
 
2542
                }
 
2543
                
 
2544
                public bool HasErrors {
 
2545
                        get {
 
2546
                                return errorReportPrinter.ErrorsCount + errorReportPrinter.FatalCounter > 0;
 
2547
                        }
 
2548
                }
 
2549
                
 
2550
                public bool HasWarnings {
 
2551
                        get {
 
2552
                                return errorReportPrinter.WarningsCount > 0;
 
2553
                        }
 
2554
                }
 
2555
                
 
2556
                public MonoDevelop.CSharp.Ast.CompilationUnit Parse (TextEditorData data)
 
2557
                {
 
2558
                        lock (CompilerCallableEntryPoint.parseLock) {
 
2559
                                CompilerCompilationUnit top;
 
2560
                                using (Stream stream = data.OpenStream ()) {
 
2561
                                        top = CompilerCallableEntryPoint.ParseFile (new string[] { "-v", "-unsafe"}, stream, data.Document.FileName ?? "empty.cs", errorReportPrinter);
 
2562
                                }
 
2563
        
 
2564
                                return Parse (top);
 
2565
                        }
 
2566
                }
 
2567
                
 
2568
                public MonoDevelop.CSharp.Ast.CompilationUnit Parse (TextReader reader)
 
2569
                {
 
2570
                        // TODO: can we optimize this to avoid the text->stream->text roundtrip?
 
2571
                        using (MemoryStream stream = new MemoryStream ()) {
 
2572
                                StreamWriter w = new StreamWriter(stream, Encoding.UTF8);
 
2573
                                char[] buffer = new char[2048];
 
2574
                                int read;
 
2575
                                while ((read = reader.ReadBlock(buffer, 0, buffer.Length)) > 0)
 
2576
                                        w.Write(buffer, 0, read);
 
2577
                                w.Flush(); // we can't close the StreamWriter because that would also close the MemoryStream
 
2578
                                stream.Position = 0;
 
2579
                                return Parse(stream);
 
2580
                        }
 
2581
                }
 
2582
                
 
2583
                public MonoDevelop.CSharp.Ast.CompilationUnit Parse (Stream stream)
 
2584
                {
 
2585
                        lock (CompilerCallableEntryPoint.parseLock) {
 
2586
                                CompilerCompilationUnit top = CompilerCallableEntryPoint.ParseFile (new string[] { "-v", "-unsafe"}, stream, "parsed.cs", errorReportPrinter);
 
2587
                                
 
2588
                                if (top == null)
 
2589
                                        return null;
 
2590
                                CSharpParser.ConversionVisitor conversionVisitor = new ConversionVisitor (top.LocationsBag);
 
2591
                                top.UsingsBag.Global.Accept (conversionVisitor);
 
2592
                                InsertComments (top, conversionVisitor);
 
2593
                                return conversionVisitor.Unit;
 
2594
                        }
 
2595
                }
 
2596
                
 
2597
                public IEnumerable<AttributedNode> ParseTypeMembers(TextReader reader)
 
2598
                {
 
2599
                        string code = "class MyClass { " + reader.ReadToEnd() + "}";
 
2600
                        var cu = Parse(new StringReader(code));
 
2601
                        var td = cu.Children.FirstOrDefault() as TypeDeclaration;
 
2602
                        if (td != null)
 
2603
                                return td.Members;
 
2604
                        return Enumerable.Empty<AttributedNode> ();
 
2605
                }
 
2606
                
 
2607
                public IEnumerable<MonoDevelop.CSharp.Ast.Statement> ParseStatements(TextReader reader)
 
2608
                {
 
2609
                        string code = "void M() { " + reader.ReadToEnd() + "}";
 
2610
                        var members = ParseTypeMembers(new StringReader(code));
 
2611
                        var method = members.FirstOrDefault() as MethodDeclaration;
 
2612
                        if (method != null && method.Body != null)
 
2613
                                return method.Body.Statements;
 
2614
                        return Enumerable.Empty<MonoDevelop.CSharp.Ast.Statement> ();
 
2615
                }
 
2616
                
 
2617
                public AstType ParseTypeReference(TextReader reader)
 
2618
                {
 
2619
                        // TODO: add support for parsing type references
 
2620
                        throw new NotImplementedException();
 
2621
                }
 
2622
                
 
2623
                public AstNode ParseExpression(TextReader reader)
 
2624
                {
 
2625
                        var es = ParseStatements(new StringReader("tmp = " + reader.ReadToEnd() + ";")).FirstOrDefault() as MonoDevelop.CSharp.Ast.ExpressionStatement;
 
2626
                        if (es != null) {
 
2627
                                AssignmentExpression ae = es.Expression as AssignmentExpression;
 
2628
                                if (ae != null)
 
2629
                                        return ae.Right;
 
2630
                        }
 
2631
                        return null;
 
2632
                }
 
2633
                
 
2634
                /// <summary>
 
2635
                /// Parses a file snippet; guessing what the code snippet represents (compilation unit, type members, block, type reference, expression).
 
2636
                /// </summary>
 
2637
                public AstNode ParseSnippet(TextReader reader)
 
2638
                {
 
2639
                        // TODO: add support for parsing a part of a file
 
2640
                        throw new NotImplementedException();
 
2641
                }
1856
2642
        }
1857
 
}*/
 
2643
}