← Back to branch summary

~ubuntu-branches/ubuntu/saucy/monodevelop/saucy-proposed

« 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: 2010-09-10 16:54:48 UTC
  • mfrom: (19.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20100910165448-0rybfk25zd4o9431
Tags: 2.4+dfsg-2
* debian/patches/inject_Mono.Debugger.Soft_source.patch,
  debian/patches/use_system_Mono.Debugger.Soft.patch,
  debian/control:
  + Build against system Soft Debugger, since we now have a new
    enough Mono to match MonoDevelop's required API

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/CSharpBinding/MonoDevelop.CSharp.Parser/CSharpParser.cs
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
 
 
27
26
/*
28
27
using System;
 
28
using System.Linq;
29
29
using System.Collections.Generic;
30
30
using System.IO;
31
31
using Mono.CSharp;
32
32
using System.Text;
 
33
using Mono.TextEditor;
33
34
using MonoDevelop.CSharp.Dom;
 
35
using MonoDevelop.Projects.Dom;
34
36
 
35
37
namespace MonoDevelop.CSharp.Parser
36
38
{
37
39
        public class CSharpParser
38
40
        {
39
 
                class Dumper : IStructuralVisitor
 
41
                class ConversionVisitor : AbstractStructuralVisitor
40
42
                {
41
 
                        
42
 
                        public Dumper ()
43
 
                        {
44
 
                                currentNode = new NamespaceDeclaration ();
45
 
                        }
46
 
                        
47
 
                        #region IStructuralVisitor Members
48
 
                        
49
 
                        public void Visit (MemberCore member)
 
43
                        MonoDevelop.CSharp.Dom.CompilationUnit unit = new MonoDevelop.CSharp.Dom.CompilationUnit ();
 
44
                        
 
45
                        public MonoDevelop.CSharp.Dom.CompilationUnit Unit {
 
46
                                get {
 
47
                                        return unit;
 
48
                                }
 
49
                                set {
 
50
                                        unit = value;
 
51
                                }
 
52
                        }
 
53
                        
 
54
                        public LocationStorage LocationStorage  {
 
55
                                get;
 
56
                                private set;
 
57
                        }
 
58
                        
 
59
                        public ConversionVisitor (LocationStorage locationStorage)
 
60
                        {
 
61
                                this.LocationStorage = locationStorage;
 
62
                        }
 
63
                        
 
64
                        public static DomLocation Convert (Mono.CSharp.Location loc)
 
65
                        {
 
66
                                return new DomLocation (loc.Row - 1, loc.Column - 1);
 
67
                        }
 
68
                        
 
69
                        #region Global
 
70
                        public override void Visit (ModuleCompiled mc)
 
71
                        {
 
72
                                base.Visit (mc);
 
73
                        }
 
74
 
 
75
                        public override void Visit (MemberCore member)
50
76
                        {
51
77
                                Console.WriteLine ("Unknown member:");
52
 
        //                      Console.WriteLine (member.GetType () + "-> Member {0}", member.GetSignatureForError ());
53
 
                        }
54
 
                        
55
 
                        AbstractCSharpNode currentNode;
56
 
                        
57
 
                        public void Visit (TypeContainer typeContainer)
58
 
                        {
59
 
        //                      TypeDeclaration typeDeclaration = new TypeDeclaration ();
60
 
                                Console.WriteLine (typeContainer.MemberName);
61
 
                                
62
 
                                
 
78
                                Console.WriteLine (member.GetType () + "-> Member {0}", member.GetSignatureForError ());
 
79
                        }
 
80
                        
 
81
                        Stack<TypeDeclaration> typeStack = new Stack<TypeDeclaration> ();
 
82
                        
 
83
                        public override void Visit (Class c)
 
84
                        {
 
85
                                TypeDeclaration newType = new TypeDeclaration ();
 
86
                                newType.ClassType = MonoDevelop.Projects.Dom.ClassType.Class;
 
87
                                
 
88
                                LocationDescriptor location = LocationStorage.Get (c);
 
89
                                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);
 
92
                                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);
 
97
                                        AddConstraints (newType, c);
 
98
                                }
 
99
                                
 
100
                                newType.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AbstractCSharpNode.Roles.LBrace);
 
101
                                typeStack.Push (newType);
 
102
                                base.Visit (c);
 
103
                                newType.AddChild (new CSharpTokenNode  (Convert (location[3]), 1), AbstractCSharpNode.Roles.RBrace);
 
104
                                typeStack.Pop ();
 
105
                                AddType (newType);
 
106
                        }
 
107
                        
 
108
                        public override void Visit (Struct s)
 
109
                        {
 
110
                                TypeDeclaration newType = new TypeDeclaration ();
 
111
                                newType.ClassType = MonoDevelop.Projects.Dom.ClassType.Struct;
 
112
                                
 
113
                                LocationDescriptor location = LocationStorage.Get (s);
 
114
                                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);
 
117
                                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);
 
122
                                        AddConstraints (newType, s);
 
123
                                }
 
124
                                
 
125
                                newType.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AbstractCSharpNode.Roles.LBrace);
 
126
                                typeStack.Push (newType);
 
127
                                base.Visit (s);
 
128
                                newType.AddChild (new CSharpTokenNode  (Convert (location[3]), 1), AbstractCSharpNode.Roles.RBrace);
 
129
                                typeStack.Pop ();
 
130
                                AddType (newType);
 
131
                        }
 
132
                        
 
133
                        public override void Visit (Interface i)
 
134
                        {
 
135
                                TypeDeclaration newType = new TypeDeclaration ();
 
136
                                newType.ClassType = MonoDevelop.Projects.Dom.ClassType.Interface;
 
137
                                
 
138
                                LocationDescriptor location = LocationStorage.Get (i);
 
139
                                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);
 
142
                                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);
 
147
                                        AddConstraints (newType, i);
 
148
                                }
 
149
                                
 
150
                                newType.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AbstractCSharpNode.Roles.LBrace);
 
151
                                typeStack.Push (newType);
 
152
                                base.Visit (i);
 
153
                                newType.AddChild (new CSharpTokenNode  (Convert (location[3]), 1), AbstractCSharpNode.Roles.RBrace);
 
154
                                typeStack.Pop ();
 
155
                                AddType (newType);
 
156
                        }
 
157
                        
 
158
                        public override void Visit (Mono.CSharp.Delegate d)
 
159
                        {
 
160
                                DelegateDeclaration newDelegate = new DelegateDeclaration ();
 
161
                                LocationDescriptor location = LocationStorage.Get (d);
 
162
                                
 
163
                                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);
 
168
                                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);
 
173
                                        AddConstraints (newDelegate, d);
 
174
                                }
 
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
                                
 
180
                                AddType (newDelegate);
 
181
                        }
 
182
                        
 
183
                        void AddType (INode child)
 
184
                        {
 
185
                                if (typeStack.Count > 0) {
 
186
                                        typeStack.Peek ().AddChild (child);
 
187
                                } else {
 
188
                                        unit.AddChild (child);
 
189
                                }
 
190
                        }
 
191
                        
 
192
                        public override void Visit (Mono.CSharp.Enum e)
 
193
                        {
 
194
                                TypeDeclaration newType = new TypeDeclaration ();
 
195
                                newType.ClassType = MonoDevelop.Projects.Dom.ClassType.Enum;
 
196
                                LocationDescriptor location = LocationStorage.Get (e);
 
197
                                
 
198
                                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);
 
203
                                typeStack.Push (newType);
 
204
                                base.Visit (e);
 
205
                                newType.AddChild (new CSharpTokenNode  (Convert (location[3]), 1), AbstractCSharpNode.Roles.RBrace);
 
206
                                typeStack.Pop ();
 
207
                                AddType (newType);
 
208
                        }
 
209
                        
 
210
                        public override void Visit (EnumMember em)
 
211
                        {
 
212
                                FieldDeclaration newField = new FieldDeclaration ();
 
213
                                VariableInitializer variable = new VariableInitializer ();
 
214
                                
 
215
                                variable.AddChild (new Identifier (em.Name, Convert (em.Location)), AbstractNode.Roles.Identifier);
 
216
                                
 
217
                                if (em.Initializer != null) {
 
218
                                        INode initializer = (INode)Visit (em.Initializer);
 
219
                                        if (initializer != null)
 
220
                                                variable.AddChild (initializer, AbstractNode.Roles.Initializer);
 
221
                                }
 
222
                                
 
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;
 
230
                        }
 
231
                        #endregion
 
232
                        
 
233
                        #region Type members
 
234
                        public override void Visit (FixedField f)
 
235
                        {
 
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
                                }
 
254
                                
 
255
                                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);
 
258
                        }
 
259
                        
 
260
                        Dictionary<DomLocation, FieldDeclaration> visitedFields = new Dictionary<DomLocation, FieldDeclaration> ();
 
261
                        public override void Visit (Field f)
 
262
                        {
 
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);
 
283
                        }
 
284
                        
 
285
                        public override void Visit (Operator o)
 
286
                        {
 
287
                                OperatorDeclaration newOperator = new OperatorDeclaration ();
 
288
                                newOperator.OperatorType = (OperatorType)o.OperatorType;
 
289
                                
 
290
                                LocationDescriptor location = LocationStorage.Get (o);
 
291
                                AddModifiers (newOperator, location);
 
292
                                
 
293
                                newOperator.AddChild ((INode)o.TypeName.Accept (this), AbstractNode.Roles.ReturnType);
 
294
                                
 
295
                                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);
 
298
                                } 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);
 
301
                                } else {
 
302
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[2]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
 
303
                                        
 
304
                                        int opLength = 1;
 
305
                                        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:
 
312
//                                      case OperatorType.LogicalAnd:
 
313
//                                      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;
 
322
                                        }
 
323
                                        newOperator.AddChild (new CSharpTokenNode (Convert (location[3]), opLength), OperatorDeclaration.OperatorTypeRole);
 
324
                                }
 
325
                                
 
326
                                newOperator.AddChild (new CSharpTokenNode (Convert (location[0]), 1), OperatorDeclaration.Roles.LPar);
 
327
                                AddParameter (newOperator, o.ParameterInfo);
 
328
                                newOperator.AddChild (new CSharpTokenNode (Convert (location[1]), 1), OperatorDeclaration.Roles.RPar);
 
329
                                
 
330
                                if (o.Block != null)
 
331
                                        newOperator.AddChild ((INode)o.Block.Accept (this), OperatorDeclaration.Roles.Body);
 
332
                                
 
333
                                typeStack.Peek ().AddChild (newOperator, TypeDeclaration.Roles.Member);
 
334
                        }
 
335
                        
 
336
                        public override void Visit (Indexer indexer)
 
337
                        {
 
338
                                IndexerDeclaration newIndexer = new IndexerDeclaration ();
 
339
                                
 
340
                                LocationDescriptor location = LocationStorage.Get (indexer);
 
341
                                AddModifiers (newIndexer, location);
 
342
                                
 
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);
 
350
                                if (indexer.Get != null) {
 
351
                                        MonoDevelop.CSharp.Dom.Accessor getAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
 
352
                                        LocationDescriptor getLocation = LocationStorage.Get (indexer.Get);
 
353
                                        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);
 
358
                                }
 
359
                                
 
360
                                if (indexer.Set != null) {
 
361
                                        MonoDevelop.CSharp.Dom.Accessor setAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
 
362
                                        LocationDescriptor setLocation = LocationStorage.Get (indexer.Set);
 
363
                                        AddModifiers (setAccessor, setLocation);
 
364
                                        setAccessor.AddChild (new CSharpTokenNode (Convert (setLocation[0]), "set".Length), PropertyDeclaration.Roles.Keyword);
 
365
                                        
 
366
                                        if (indexer.Set.Block != null)
 
367
                                                setAccessor.AddChild ((INode)indexer.Set.Block.Accept (this), MethodDeclaration.Roles.Body);
 
368
                                        newIndexer.AddChild (setAccessor, PropertyDeclaration.PropertySetRole);
 
369
                                }
 
370
                                
 
371
                                newIndexer.AddChild (new CSharpTokenNode (Convert (location[3]), 1), IndexerDeclaration.Roles.RBrace);
 
372
                                
 
373
                                typeStack.Peek ().AddChild (newIndexer, TypeDeclaration.Roles.Member);
 
374
                        }
 
375
                        
 
376
                        public override void Visit (Method m)
 
377
                        {
 
378
                                MethodDeclaration newMethod = new MethodDeclaration ();
 
379
                                
 
380
                                LocationDescriptor location = LocationStorage.Get (m);
 
381
                                AddModifiers (newMethod, location);
 
382
                                
 
383
                                newMethod.AddChild ((INode)m.TypeName.Accept (this), AbstractNode.Roles.ReturnType);
 
384
                                newMethod.AddChild (new Identifier (m.Name, Convert (m.Location)), AbstractNode.Roles.Identifier);
 
385
                                
 
386
                                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);
 
391
                                        
 
392
                                        AddConstraints (newMethod, m.GenericMethod);
 
393
                                }
 
394
                                
 
395
                                newMethod.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LPar);
 
396
                                
 
397
                                AddParameter (newMethod, m.ParameterInfo);
 
398
                                
 
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);
 
404
                        }
 
405
                        
 
406
                        static Dictionary<Mono.CSharp.Modifiers, MonoDevelop.Projects.Dom.Modifiers> modifierTable = new Dictionary<Mono.CSharp.Modifiers, MonoDevelop.Projects.Dom.Modifiers> ();
 
407
                        static ConversionVisitor ()
 
408
                        {
 
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;
 
426
                        }
 
427
                        
 
428
                        void AddModifiers (AbstractNode parent, Mono.CSharp.LocationDescriptor location)
 
429
                        {
 
430
                                if (location.Modifiers == null)
 
431
                                        return;
 
432
                                foreach (var modifier in location.Modifiers) {
 
433
                                        parent.AddChild (new CSharpModifierToken (Convert (modifier.Item1), modifierTable[modifier.Item2]), AbstractNode.Roles.Modifier);
 
434
                                }
 
435
                        }
 
436
                        
 
437
                        public override void Visit (Property p)
 
438
                        {
 
439
                                PropertyDeclaration newProperty = new PropertyDeclaration ();
 
440
                                
 
441
                                LocationDescriptor location = LocationStorage.Get (p);
 
442
                                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);
 
447
                                
 
448
                                if (p.Get != null) {
 
449
                                        MonoDevelop.CSharp.Dom.Accessor getAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
 
450
                                        LocationDescriptor getLocation = LocationStorage.Get (p.Get);
 
451
                                        AddModifiers (getAccessor, getLocation);
 
452
                                        getAccessor.AddChild (new CSharpTokenNode (Convert (getLocation[0]), "get".Length), PropertyDeclaration.Roles.Keyword);
 
453
                                        
 
454
                                        if (p.Get.Block != null)
 
455
                                                getAccessor.AddChild ((INode)p.Get.Block.Accept (this), MethodDeclaration.Roles.Body);
 
456
                                        newProperty.AddChild (getAccessor, PropertyDeclaration.PropertyGetRole);
 
457
                                }
 
458
                                
 
459
                                if (p.Set != null) {
 
460
                                        MonoDevelop.CSharp.Dom.Accessor setAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
 
461
                                        LocationDescriptor setLocation = LocationStorage.Get (p.Set);
 
462
                                        AddModifiers (setAccessor, setLocation);
 
463
                                        setAccessor.AddChild (new CSharpTokenNode (Convert (setLocation[0]), "set".Length), PropertyDeclaration.Roles.Keyword);
 
464
                                        
 
465
                                        if (p.Set.Block != null)
 
466
                                                setAccessor.AddChild ((INode)p.Set.Block.Accept (this), MethodDeclaration.Roles.Body);
 
467
                                        newProperty.AddChild (setAccessor, PropertyDeclaration.PropertySetRole);
 
468
                                }
 
469
                                newProperty.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RBrace);
 
470
                                
 
471
                                typeStack.Peek ().AddChild (newProperty, TypeDeclaration.Roles.Member);
 
472
                        }
 
473
                        
 
474
                        public override void Visit (Constructor c)
 
475
                        {
 
476
                                ConstructorDeclaration newConstructor = new ConstructorDeclaration ();
 
477
                                LocationDescriptor location = LocationStorage.Get (c);
 
478
                                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);
 
481
                                
 
482
                                if (c.Block != null)
 
483
                                        newConstructor.AddChild ((INode)c.Block.Accept (this), ConstructorDeclaration.Roles.Body);
 
484
                                
 
485
                                typeStack.Peek ().AddChild (newConstructor, TypeDeclaration.Roles.Member);
 
486
                        }
 
487
                        
 
488
                        public override void Visit (Destructor d)
 
489
                        {
 
490
                                DestructorDeclaration newDestructor = new DestructorDeclaration ();
 
491
                                LocationDescriptor location = LocationStorage.Get (d);
 
492
                                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);
 
495
                                
 
496
                                if (d.Block != null)
 
497
                                        newDestructor.AddChild ((INode)d.Block.Accept (this), DestructorDeclaration.Roles.Body);
 
498
                                
 
499
                                typeStack.Peek ().AddChild (newDestructor, TypeDeclaration.Roles.Member);
 
500
                        }
 
501
                        
 
502
                        public override void Visit (EventField e)
 
503
                        {
 
504
                                EventDeclaration newEvent = new EventDeclaration ();
 
505
                                
 
506
                                LocationDescriptor location = LocationStorage.Get (e);
 
507
                                AddModifiers (newEvent, location);
 
508
                                
 
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);
 
513
                                
 
514
                                typeStack.Peek ().AddChild (newEvent, TypeDeclaration.Roles.Member);
 
515
                        }
 
516
                        
 
517
                        public override void Visit (EventProperty ep)
 
518
                        {
 
519
                                EventDeclaration newEvent = new EventDeclaration ();
 
520
                                
 
521
                                LocationDescriptor location = LocationStorage.Get (ep);
 
522
                                AddModifiers (newEvent, location);
 
523
                                
 
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);
 
528
                                
 
529
                                if (ep.Add != null) {
 
530
                                        MonoDevelop.CSharp.Dom.Accessor addAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
 
531
                                        LocationDescriptor addLocation = LocationStorage.Get (ep.Add);
 
532
                                        AddModifiers (addAccessor, addLocation);
 
533
                                        addAccessor.AddChild (new CSharpTokenNode (Convert (addLocation[0]), "add".Length), EventDeclaration.Roles.Keyword);
 
534
                                        if (ep.Add.Block != null)
 
535
                                                addAccessor.AddChild ((INode)ep.Add.Block.Accept (this), EventDeclaration.Roles.Body);
 
536
                                        newEvent.AddChild (addAccessor, EventDeclaration.EventAddRole);
 
537
                                }
 
538
                                
 
539
                                if (ep.Remove != null) {
 
540
                                        MonoDevelop.CSharp.Dom.Accessor removeAccessor = new MonoDevelop.CSharp.Dom.Accessor ();
 
541
                                        LocationDescriptor removeLocation = LocationStorage.Get (ep.Remove);
 
542
                                        AddModifiers (removeAccessor, removeLocation);
 
543
                                        removeAccessor.AddChild (new CSharpTokenNode (Convert (removeLocation[0]), "remove".Length), EventDeclaration.Roles.Keyword);
 
544
                                        
 
545
                                        if (ep.Remove.Block != null)
 
546
                                                removeAccessor.AddChild ((INode)ep.Remove.Block.Accept (this), EventDeclaration.Roles.Body);
 
547
                                        newEvent.AddChild (removeAccessor, EventDeclaration.EventRemoveRole);
 
548
                                }
 
549
                                newEvent.AddChild (new CSharpTokenNode (Convert (location[2]), 1), EventDeclaration.Roles.RBrace);
 
550
                                
 
551
                                typeStack.Peek ().AddChild (newEvent, TypeDeclaration.Roles.Member);
 
552
                        }
 
553
                        
 
554
                        #endregion
 
555
                        
 
556
                        #region Statements
 
557
                        public override object Visit (Statement stmt)
 
558
                        {
 
559
                                Console.WriteLine ("unknown statement:" + stmt);
 
560
                                return null;
 
561
                        }
 
562
                        
 
563
                        public override object Visit (Mono.CSharp.EmptyStatement emptyStatement)
 
564
                        {
 
565
                                var result = new MonoDevelop.CSharp.Dom.EmptyStatement ();
 
566
                                result.Location = Convert (emptyStatement.loc);
 
567
                                return result;
 
568
                        }
 
569
                        
 
570
                        public override object Visit (EmptyExpressionStatement emptyExpressionStatement)
 
571
                        {
 
572
                                // indicates an error
 
573
                                return new MonoDevelop.CSharp.Dom.EmptyStatement ();
63
574
                        }
64
575
                
65
 
                        public void Visit (Method member)
66
 
                        {
67
 
                                
68
 
                        }
69
 
                                
70
 
                        public void Visit (Field member)
71
 
                        {
72
 
                                
73
 
                        }
74
 
                        
75
 
                        public void Visit (Constructor member)
76
 
                        {
77
 
                                
78
 
                        }
79
 
                        
80
 
                        public void Visit (Destructor member)
81
 
                        {
82
 
                                
83
 
                        }
84
 
                        
85
 
                        public void Visit (Operator member)
86
 
                        {
87
 
                                
88
 
                        }
89
 
                        
90
 
                        public void Visit (Property member)
91
 
                        {
92
 
                                
93
 
                        }
94
 
                        
95
 
                        public void Visit (Event member)
96
 
                        {
97
 
                                
 
576
                        
 
577
                        public override object Visit (If ifStatement)
 
578
                        {
 
579
                                var result = new IfElseStatement ();
 
580
                                
 
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);
 
589
                                
 
590
                                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);
 
593
                                }
 
594
                                
 
595
                                return result;
 
596
                        }
 
597
                        
 
598
                        public override object Visit (Do doStatement)
 
599
                        {
 
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);
 
609
                                
 
610
                                return result;
 
611
                        }
 
612
                        
 
613
                        public override object Visit (While whileStatement)
 
614
                        {
 
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);
 
624
                                
 
625
                                return result;
 
626
                        }
 
627
                        
 
628
                        public override object Visit (For forStatement)
 
629
                        {
 
630
                                var result = new ForStatement ();
 
631
                                
 
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);
 
640
                                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);
 
648
                                
 
649
                                return result;
 
650
                        }
 
651
                        
 
652
                        public override object Visit (StatementExpression statementExpression)
 
653
                        {
 
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);
 
659
                                return result;
 
660
                        }
 
661
                        
 
662
                        public override object Visit (Return returnStatement)
 
663
                        {
 
664
                                var result = new ReturnStatement ();
 
665
                                LocationDescriptor location = LocationStorage.Get (returnStatement);
 
666
                                
 
667
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "return".Length), ReturnStatement.Roles.Keyword);
 
668
                                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);
 
671
                                
 
672
                                return result;
 
673
                        }
 
674
                        
 
675
                        public override object Visit (Goto gotoStatement)
 
676
                        {
 
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);
 
683
                                
 
684
                                return result;
 
685
                        }
 
686
                        
 
687
                        public override object Visit (LabeledStatement labeledStatement)
 
688
                        {
 
689
                                var result = new LabelStatement ();
 
690
                                result.AddChild (new Identifier (labeledStatement.Name, Convert (labeledStatement.loc)), LabelStatement.Roles.Identifier);
 
691
                                return result;
 
692
                        }
 
693
                        
 
694
                        public override object Visit (GotoDefault gotoDefault)
 
695
                        {
 
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);
 
702
                                
 
703
                                return result;
 
704
                        }
 
705
                        
 
706
                        public override object Visit (GotoCase gotoCase)
 
707
                        {
 
708
                                var result = new GotoStatement (GotoType.Case);
 
709
                                LocationDescriptor location = LocationStorage.Get (gotoCase);
 
710
                                
 
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);
 
715
                                return result;
 
716
                        }
 
717
                        
 
718
                        public override object Visit (Throw throwStatement)
 
719
                        {
 
720
                                var result = new ThrowStatement ();
 
721
                                LocationDescriptor location = LocationStorage.Get (throwStatement);
 
722
                                
 
723
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "throw".Length), ThrowStatement.Roles.Keyword);
 
724
                                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);
 
727
                                return result;
 
728
                        }
 
729
                        
 
730
                        public override object Visit (Break breakStatement)
 
731
                        {
 
732
                                var result = new BreakStatement ();
 
733
                                LocationDescriptor location = LocationStorage.Get (breakStatement);
 
734
                                
 
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);
 
737
                                return result;
 
738
                        }
 
739
                        
 
740
                        public override object Visit (Continue continueStatement)
 
741
                        {
 
742
                                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);
 
747
                                return result;
 
748
                        }
 
749
                        
 
750
                        public static bool IsLower (Location left, Location right)
 
751
                        {
 
752
                                return left.Row < right.Row || left.Row == right.Row && left.Column < right.Column;
 
753
                        }
 
754
                        public override object Visit (Block blockStatement)
 
755
                        {
 
756
                                if (blockStatement.IsGenerated)
 
757
                                        return blockStatement.Statements.Last ().Accept (this);
 
758
                                var result = new BlockStatement ();
 
759
                                result.AddChild (new CSharpTokenNode (Convert (blockStatement.StartLocation), 1), AbstractCSharpNode.Roles.LBrace);
 
760
                                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
                        
 
792
                        public override object Visit (Switch switchStatement)
 
793
                        {
 
794
                                var result = new SwitchStatement ();
 
795
                                
 
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);
 
803
                                foreach (var section in switchStatement.Sections) {
 
804
                                        var newSection = new MonoDevelop.CSharp.Dom.SwitchSection ();
 
805
                                        foreach (var caseLabel in section.Labels) {
 
806
                                                var newLabel = new CaseLabel ();
 
807
                                                newLabel.AddChild (new CSharpTokenNode (Convert (caseLabel.Location), "case".Length), SwitchStatement.Roles.Keyword);
 
808
                                                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);
 
814
                                        result.AddChild (newSection, SwitchStatement.SwitchSectionRole);
 
815
                                }
 
816
                                
 
817
                                result.AddChild (new CSharpTokenNode (Convert (location[4]), 1), SwitchStatement.Roles.RBrace);
 
818
                                return result;
 
819
                        }
 
820
                        
 
821
                        public override object Visit (Lock lockStatement)
 
822
                        {
 
823
                                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);
 
831
                                
 
832
                                return result;
 
833
                        }
 
834
                        
 
835
                        public override object Visit (Unchecked uncheckedStatement)
 
836
                        {
 
837
                                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);
 
841
                                return result;
 
842
                        }
 
843
                        
 
844
                        
 
845
                        public override object Visit (Checked checkedStatement)
 
846
                        {
 
847
                                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);
 
851
                                return result;
 
852
                        }
 
853
                        
 
854
                        public override object Visit (Unsafe unsafeStatement)
 
855
                        {
 
856
                                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);
 
860
                                return result;
 
861
                        }
 
862
                        
 
863
                        public override object Visit (Fixed fixedStatement)
 
864
                        {
 
865
                                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);
 
875
                                }
 
876
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FixedStatement.Roles.RPar);
 
877
                                result.AddChild ((INode)fixedStatement.Statement.Accept (this), FixedStatement.Roles.EmbeddedStatement);
 
878
                                return result;
 
879
                        }
 
880
                        
 
881
                        public override object Visit (TryFinally tryFinallyStatement)
 
882
                        {
 
883
                                TryCatchStatement result;
 
884
                                LocationDescriptor location = LocationStorage.Get (tryFinallyStatement);
 
885
                                
 
886
                                if (tryFinallyStatement.Stmt is TryCatch) {
 
887
                                        result = (TryCatchStatement)tryFinallyStatement.Stmt.Accept (this);
 
888
                                } else {
 
889
                                        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);
 
892
                                }
 
893
                                
 
894
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "finally".Length), TryCatchStatement.FinallyKeywordRole);
 
895
                                result.AddChild ((INode)tryFinallyStatement.Fini.Accept (this), TryCatchStatement.FinallyBlockRole);
 
896
                                
 
897
                                return result;
 
898
                        }
 
899
                        
 
900
                        CatchClause ConvertCatch (Catch ctch) 
 
901
                        {
 
902
                                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);
 
914
                                }
 
915
                                
 
916
                                result.AddChild ((INode)ctch.Block.Accept (this), CatchClause.Roles.Body);
 
917
                                
 
918
                                return result;
 
919
                        }
 
920
                        
 
921
                        public override object Visit (TryCatch tryCatchStatement)
 
922
                        {
 
923
                                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);
 
927
                                foreach (Catch ctch in tryCatchStatement.Specific) {
 
928
                                        result.AddChild (ConvertCatch (ctch), TryCatchStatement.CatchClauseRole);
 
929
                                }
 
930
                                if (tryCatchStatement.General != null)
 
931
                                        result.AddChild (ConvertCatch (tryCatchStatement.General), TryCatchStatement.CatchClauseRole);
 
932
                                
 
933
                                return result;
 
934
                        }
 
935
                        
 
936
                        public override object Visit (Using usingStatement)
 
937
                        {
 
938
                                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
                        
 
972
                        
 
973
                        public override object Visit (Foreach foreachStatement)
 
974
                        {
 
975
                                var result = new ForeachStatement ();
 
976
                                
 
977
                                LocationDescriptor location = LocationStorage.Get (foreachStatement);
 
978
                                
 
979
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), "foreach".Length), ForeachStatement.ForEachKeywordRole);
 
980
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ForeachStatement.Roles.LPar);
 
981
                                
 
982
                                if (foreachStatement.TypeExpr == null)
 
983
                                        result.AddChild ((INode)foreachStatement.TypeExpr.Accept (this), ForeachStatement.Roles.ReturnType);
 
984
                                if (foreachStatement.Variable != null)
 
985
                                        result.AddChild ((INode)foreachStatement.Variable.Accept (this), ForeachStatement.Roles.Identifier);
 
986
                                
 
987
                                result.AddChild (new CSharpTokenNode (Convert (location[3]), "in".Length), ForeachStatement.InKeywordRole);
 
988
                                
 
989
                                if (foreachStatement.Expr != null)
 
990
                                        result.AddChild ((INode)foreachStatement.Expr.Accept (this), ForeachStatement.Roles.Initializer);
 
991
                                
 
992
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ForeachStatement.Roles.RPar);
 
993
                                result.AddChild ((INode)foreachStatement.Statement.Accept (this), ForeachStatement.Roles.EmbeddedStatement);
 
994
                                
 
995
                                return result;
 
996
                        }
 
997
                        
 
998
                        public override object Visit (Yield yieldStatement)
 
999
                        {
 
1000
                                var result = new YieldStatement ();
 
1001
                                LocationDescriptor location = LocationStorage.Get (yieldStatement);
 
1002
                                
 
1003
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "yield".Length), YieldStatement.YieldKeywordRole);
 
1004
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), "return".Length), YieldStatement.ReturnKeywordRole);
 
1005
                                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);
 
1008
                                
 
1009
                                return result;
 
1010
                        }
 
1011
                        
 
1012
                        public override object Visit (YieldBreak yieldBreakStatement)
 
1013
                        {
 
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);
 
1019
                                return result;
 
1020
                        }
 
1021
                        #endregion
 
1022
                        
 
1023
                        #region Expression
 
1024
                        public override object Visit (Expression expression)
 
1025
                        {
 
1026
                                Console.WriteLine ("Visit unknown expression:" + expression);
 
1027
                                return null;
 
1028
                        }
 
1029
                        
 
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;
 
1039
                        }
 
1040
 
 
1041
                        public override object Visit (LocalVariableReference localVariableReference)
 
1042
                        {
 
1043
                                return new Identifier (localVariableReference.Name, Convert (localVariableReference.Location));;
 
1044
                        }
 
1045
 
 
1046
                        public override object Visit (MemberAccess memberAccess)
 
1047
                        {
 
1048
                                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);
 
1051
                                if (memberAccess.TypeArguments != null)  {
 
1052
                                        LocationDescriptor location = LocationStorage.Get (memberAccess);
 
1053
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MemberReferenceExpression.Roles.LChevron);
 
1054
                                        AddTypeArguments (result, location, memberAccess.TypeArguments);
 
1055
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MemberReferenceExpression.Roles.RChevron);
 
1056
                                }
 
1057
                                return result;
 
1058
                        }
 
1059
                        
 
1060
                        public override object Visit (Constant constant)
 
1061
                        {
 
1062
                                var result = new PrimitiveExpression (constant.GetValue (), Convert (constant.Location), constant.AsString ().Length);
 
1063
                                return result;
 
1064
                        }
 
1065
 
 
1066
                        public override object Visit (SimpleName simpleName)
 
1067
                        {
 
1068
                                var result = new FullTypeName ();
 
1069
                                result.AddChild (new Identifier (simpleName.Name, Convert (simpleName.Location)), FullTypeName.Roles.Identifier);
 
1070
                                if (simpleName.TypeArguments != null)  {
 
1071
                                        LocationDescriptor location = LocationStorage.Get (simpleName);
 
1072
                                        result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FullTypeName.Roles.LChevron);
 
1073
                                        AddTypeArguments (result, location, simpleName.TypeArguments);
 
1074
                                        result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FullTypeName.Roles.RChevron);
 
1075
                                }
 
1076
                                return result;
 
1077
                        }
 
1078
                        
 
1079
                        public override object Visit (BooleanExpression booleanExpression)
 
1080
                        {
 
1081
                                return booleanExpression.Expr.Accept (this);
 
1082
                        }
 
1083
 
 
1084
                        
 
1085
                        public override object Visit (Mono.CSharp.ParenthesizedExpression parenthesizedExpression)
 
1086
                        {
 
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);
 
1092
                                return result;
 
1093
                        }
 
1094
                        
 
1095
                        public override object Visit (Unary unaryExpression)
 
1096
                        {
 
1097
                                var result = new UnaryOperatorExpression ();
 
1098
                                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;
 
1114
                                }
 
1115
                                result.AddChild (new CSharpTokenNode (Convert (unaryExpression.Location), 1), UnaryOperatorExpression.Operator);
 
1116
                                result.AddChild ((INode)unaryExpression.Expr.Accept (this), UnaryOperatorExpression.Roles.Expression);
 
1117
                                return result;
 
1118
                        }
 
1119
                        
 
1120
                        public override object Visit (UnaryMutator unaryMutatorExpression)
 
1121
                        {
 
1122
                                var result = new UnaryOperatorExpression ();
 
1123
                                
 
1124
                                INode expression = (INode)unaryMutatorExpression.Expr.Accept (this);
 
1125
                                LocationDescriptor location = LocationStorage.Get (unaryMutatorExpression);
 
1126
                                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;
 
1148
                                }
 
1149
                                
 
1150
                                return result;
 
1151
                        }
 
1152
                        
 
1153
                        public override object Visit (Indirection indirectionExpression)
 
1154
                        {
 
1155
                                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);
 
1160
                                return result;
 
1161
                        }
 
1162
                        
 
1163
                        public override object Visit (Is isExpression)
 
1164
                        {
 
1165
                                var result = new IsExpression ();
 
1166
                                result.AddChild ((INode)isExpression.Expr.Accept (this), IsExpression.Roles.Expression);
 
1167
                                result.AddChild (new CSharpTokenNode (Convert (isExpression.Location), "is".Length), IsExpression.Roles.Keyword);
 
1168
                                result.AddChild ((INode)isExpression.ProbeType.Accept (this), IsExpression.Roles.ReturnType);
 
1169
                                return result;
 
1170
                        }
 
1171
                        
 
1172
                        public override object Visit (As asExpression)
 
1173
                        {
 
1174
                                var result = new AsExpression ();
 
1175
                                result.AddChild ((INode)asExpression.Expr.Accept (this), AsExpression.Roles.Expression);
 
1176
                                result.AddChild (new CSharpTokenNode (Convert (asExpression.Location), "as".Length), AsExpression.Roles.Keyword);
 
1177
                                result.AddChild ((INode)asExpression.ProbeType.Accept (this), AsExpression.Roles.ReturnType);
 
1178
                                return result;
 
1179
                        }
 
1180
                        
 
1181
                        public override object Visit (Cast castExpression)
 
1182
                        {
 
1183
                                var result = new CastExpression ();
 
1184
                                LocationDescriptor location = LocationStorage.Get (castExpression);
 
1185
                                
 
1186
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), CastExpression.Roles.LPar);
 
1187
                                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);
 
1190
                                if (castExpression.Expr != null)
 
1191
                                        result.AddChild ((INode)castExpression.Expr.Accept (this), CastExpression.Roles.Expression);
 
1192
                                return result;
 
1193
                        }
 
1194
                        
 
1195
                        public override object Visit (ComposedCast composedCast)
 
1196
                        {
 
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);
 
1201
                                return result;
 
1202
                        }
 
1203
                        
 
1204
                        public override object Visit (Mono.CSharp.DefaultValueExpression defaultValueExpression)
 
1205
                        {
 
1206
                                var result = new MonoDevelop.CSharp.Dom.DefaultValueExpression ();
 
1207
                                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);
 
1212
                                return result;
 
1213
                        }
 
1214
                        
 
1215
                        public override object Visit (Binary binaryExpression)
 
1216
                        {
 
1217
                                var result = new BinaryOperatorExpression ();
 
1218
                                int opLength = 1;
 
1219
                                switch (binaryExpression.Oper) {
 
1220
                                        case Binary.Operator.Multiply:
 
1221
                                                result.BinaryOperatorType = BinaryOperatorType.Multiply;
 
1222
                                                break;
 
1223
                                        case Binary.Operator.Division:
 
1224
                                                result.BinaryOperatorType = BinaryOperatorType.Divide;
 
1225
                                                break;
 
1226
                                        case Binary.Operator.Modulus:
 
1227
                                                result.BinaryOperatorType = BinaryOperatorType.Modulus;
 
1228
                                                break;
 
1229
                                        case Binary.Operator.Addition:
 
1230
                                                result.BinaryOperatorType = BinaryOperatorType.Add;
 
1231
                                                break;
 
1232
                                        case Binary.Operator.Subtraction:
 
1233
                                                result.BinaryOperatorType = BinaryOperatorType.Subtract;
 
1234
                                                break;
 
1235
                                        case Binary.Operator.LeftShift:
 
1236
                                                result.BinaryOperatorType = BinaryOperatorType.ShiftLeft;
 
1237
                                                opLength = 2;
 
1238
                                                break;
 
1239
                                        case Binary.Operator.RightShift:
 
1240
                                                result.BinaryOperatorType = BinaryOperatorType.ShiftRight;
 
1241
                                                opLength = 2;
 
1242
                                                break;
 
1243
                                        case Binary.Operator.LessThan:
 
1244
                                                result.BinaryOperatorType = BinaryOperatorType.LessThan;
 
1245
                                                break;
 
1246
                                        case Binary.Operator.GreaterThan:
 
1247
                                                result.BinaryOperatorType = BinaryOperatorType.GreaterThan;
 
1248
                                                break;
 
1249
                                        case Binary.Operator.LessThanOrEqual:
 
1250
                                                result.BinaryOperatorType = BinaryOperatorType.LessThanOrEqual;
 
1251
                                                opLength = 2;
 
1252
                                                break;
 
1253
                                        case Binary.Operator.GreaterThanOrEqual:
 
1254
                                                result.BinaryOperatorType = BinaryOperatorType.GreaterThanOrEqual;
 
1255
                                                opLength = 2;
 
1256
                                                break;
 
1257
                                        case Binary.Operator.Equality:
 
1258
                                                result.BinaryOperatorType = BinaryOperatorType.Equality;
 
1259
                                                opLength = 2;
 
1260
                                                break;
 
1261
                                        case Binary.Operator.Inequality:
 
1262
                                                result.BinaryOperatorType = BinaryOperatorType.InEquality;
 
1263
                                                opLength = 2;
 
1264
                                                break;
 
1265
                                        case Binary.Operator.BitwiseAnd:
 
1266
                                                result.BinaryOperatorType = BinaryOperatorType.BitwiseAnd;
 
1267
                                                break;
 
1268
                                        case Binary.Operator.ExclusiveOr:
 
1269
                                                result.BinaryOperatorType = BinaryOperatorType.ExclusiveOr;
 
1270
                                                break;
 
1271
                                        case Binary.Operator.BitwiseOr:
 
1272
                                                result.BinaryOperatorType = BinaryOperatorType.BitwiseOr;
 
1273
                                                break;
 
1274
                                        case Binary.Operator.LogicalAnd:
 
1275
                                                result.BinaryOperatorType = BinaryOperatorType.LogicalAnd;
 
1276
                                                opLength = 2;
 
1277
                                                break;
 
1278
                                        case Binary.Operator.LogicalOr:
 
1279
                                                result.BinaryOperatorType = BinaryOperatorType.LogicalOr;
 
1280
                                                opLength = 2;
 
1281
                                                break;
 
1282
                                }
 
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);
 
1287
                                return result;
 
1288
                        }
 
1289
                        
 
1290
                        public override object Visit (Mono.CSharp.Nullable.NullCoalescingOperator nullCoalescingOperator)
 
1291
                        {
 
1292
                                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);
 
1298
                                return result;
 
1299
                        }
 
1300
                        
 
1301
                        public override object Visit (Conditional conditionalExpression)
 
1302
                        {
 
1303
                                var result = new ConditionalExpression ();
 
1304
                                
 
1305
                                result.AddChild ((INode)conditionalExpression.Expr.Accept (this), ConditionalExpression.Roles.Condition);
 
1306
                                LocationDescriptor location = LocationStorage.Get (conditionalExpression);
 
1307
                                
 
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);
 
1312
                                return result;
 
1313
                        }
 
1314
                        
 
1315
                        void AddParameter (AbstractCSharpNode parent, Mono.CSharp.ParametersCompiled parameters)
 
1316
                        {
 
1317
                                if (parameters == null || !parameters.HasParams)
 
1318
                                        return;
 
1319
                                LocationDescriptor paramLocation = LocationStorage.Get (parameters);
 
1320
                                
 
1321
                                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);
 
1326
                                        
 
1327
                                        ParameterDeclarationExpression parameterDeclarationExpression = new ParameterDeclarationExpression ();
 
1328
                                        switch (p.ParameterModifier) {
 
1329
                                        case Parameter.Modifier.OUT:
 
1330
                                                parameterDeclarationExpression.ParameterModifier = ParameterModifier.Out;
 
1331
                                                parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location.LocationList[0]), "out".Length), ParameterDeclarationExpression.Roles.Keyword);
 
1332
                                                break;
 
1333
                                        case Parameter.Modifier.REF:
 
1334
                                                parameterDeclarationExpression.ParameterModifier = ParameterModifier.Ref;
 
1335
                                                parameterDeclarationExpression.AddChild (new CSharpTokenNode (Convert (location.LocationList[0]), "ref".Length), ParameterDeclarationExpression.Roles.Keyword);
 
1336
                                                break;
 
1337
                                        case Parameter.Modifier.PARAMS:
 
1338
                                                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)
 
1368
                        {
 
1369
                                if (d == null || d.Constraints == null)
 
1370
                                        return;
 
1371
                                for (int i = 0; i < d.Constraints.Count; i++) {
 
1372
                                        Constraints c = d.Constraints[i];
 
1373
                                        LocationDescriptor location = LocationStorage.Get (c);
 
1374
                                        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);
 
1378
                                        foreach (var expr in c.ConstraintExpressions)
 
1379
                                                parent.AddChild ((INode)expr.Accept (this), InvocationExpression.Roles.TypeArgument);
 
1380
                                }
 
1381
                        }
 
1382
                        
 
1383
                        void AddArguments (AbstractCSharpNode parent, LocationDescriptor location, Mono.CSharp.Arguments args)
 
1384
                        {
 
1385
                                if (args == null)
 
1386
                                        return;
 
1387
                                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);
 
1391
                                }
 
1392
                        }
 
1393
                        
 
1394
                        public override object Visit (Invocation invocationExpression)
 
1395
                        {
 
1396
                                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);
 
1400
                                AddArguments (result, location, invocationExpression.Arguments);
 
1401
                                
 
1402
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), InvocationExpression.Roles.RPar);
 
1403
                                return result;
 
1404
                        }
 
1405
                        
 
1406
                        public override object Visit (New newExpression)
 
1407
                        {
 
1408
                                var result = new ObjectCreateExpression ();
 
1409
                                
 
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
                        }
 
1423
                        
 
1424
                        public override object Visit (ArrayCreation arrayCreationExpression)
 
1425
                        {
 
1426
                                var result = new ArrayObjectCreateExpression ();
 
1427
                                
 
1428
                                var location = LocationStorage.Get (arrayCreationExpression);
 
1429
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "new".Length), ArrayObjectCreateExpression.Roles.Keyword);
 
1430
                                
 
1431
                                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);
 
1435
                                if (arrayCreationExpression.Arguments != null) {
 
1436
                                        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);
 
1440
                                        }
 
1441
                                }
 
1442
                                result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), ArrayObjectCreateExpression.Roles.RBracket);
 
1443
                                
 
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);
 
1452
                                                }
 
1453
                                        }
 
1454
                                        result.AddChild (new CSharpTokenNode (Convert (initLocation[1]), 1), ArrayObjectCreateExpression.Roles.RBrace);
 
1455
                                }
 
1456
                                
 
1457
                                return result;
 
1458
                        }
 
1459
                        
 
1460
                        public override object Visit (This thisExpression)
 
1461
                        {
 
1462
                                var result = new ThisReferenceExpression ();
 
1463
                                result.Location = Convert (thisExpression.Location);
 
1464
                                return result;
 
1465
                        }
 
1466
                        
 
1467
                        public override object Visit (ArglistAccess argListAccessExpression)
 
1468
                        {
 
1469
                                var result = new ArgListExpression ();
 
1470
                                result.IsAccess = true;
 
1471
                                result.AddChild (new CSharpTokenNode (Convert (argListAccessExpression.Location), "__arglist".Length), ArgListExpression.Roles.Keyword);
 
1472
                                return result;
 
1473
                        }
 
1474
                        
 
1475
                        public override object Visit (Arglist argListExpression)
 
1476
                        {
 
1477
                                var result = new ArgListExpression ();
 
1478
                                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);
 
1481
                                
 
1482
                                AddArguments (result, location, argListExpression.Arguments);
 
1483
                                
 
1484
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ArgListExpression.Roles.RPar);
 
1485
                                return result;
 
1486
                        }
 
1487
                        
 
1488
                        public override object Visit (TypeOf typeOfExpression)
 
1489
                        {
 
1490
                                var result = new TypeOfExpression ();
 
1491
                                LocationDescriptor location = LocationStorage.Get (typeOfExpression);
 
1492
                                result.AddChild (new CSharpTokenNode (Convert (typeOfExpression.Location), "typeof".Length), TypeOfExpression.Roles.Keyword);
 
1493
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
 
1494
                                result.AddChild ((INode)typeOfExpression.QueriedType.Accept (this), TypeOfExpression.Roles.ReturnType);
 
1495
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
 
1496
                                return result;
 
1497
                        }
 
1498
                        
 
1499
                        public override object Visit (SizeOf sizeOfExpression)
 
1500
                        {
 
1501
                                var result = new SizeOfExpression ();
 
1502
                                LocationDescriptor location = LocationStorage.Get (sizeOfExpression);
 
1503
                                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);
 
1507
                                return result;
 
1508
                        }
 
1509
                        
 
1510
                        public override object Visit (CheckedExpr checkedExpression)
 
1511
                        {
 
1512
                                var result = new CheckedExpression ();
 
1513
                                LocationDescriptor location = LocationStorage.Get (checkedExpression);
 
1514
                                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);
 
1518
                                return result;
 
1519
                        }
 
1520
                        
 
1521
                        public override object Visit (UnCheckedExpr uncheckedExpression)
 
1522
                        {
 
1523
                                var result = new UncheckedExpression ();
 
1524
                                LocationDescriptor location = LocationStorage.Get (uncheckedExpression);
 
1525
                                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);
 
1529
                                return result;
 
1530
                        }
 
1531
                        
 
1532
                        public override object Visit (ElementAccess elementAccessExpression)
 
1533
                        {
 
1534
                                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);
 
1539
                                AddArguments (result, location, elementAccessExpression.Arguments);
 
1540
                                result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RBracket);
 
1541
                                return result;
 
1542
                        }
 
1543
                        
 
1544
                        public override object Visit (BaseAccess baseAccessExpression)
 
1545
                        {
 
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
                                
 
1558
                                return result;
 
1559
                        }
 
1560
                        
 
1561
                        public override object Visit (StackAlloc stackAllocExpression)
 
1562
                        {
 
1563
                                var result = new StackAllocExpression ();
 
1564
                                
 
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);
 
1571
                                return result;
 
1572
                        }
 
1573
                        
 
1574
                        public override object Visit (SimpleAssign simpleAssign)
 
1575
                        {
 
1576
                                var result = new AssignmentExpression ();
 
1577
                                
 
1578
                                LocationDescriptor location = LocationStorage.Get (simpleAssign);
 
1579
                                
 
1580
                                result.AssignmentOperatorType = AssignmentOperatorType.Assign;
 
1581
                                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);
 
1584
                                
 
1585
                                if (simpleAssign.Source != null)
 
1586
                                        result.AddChild ((INode)simpleAssign.Source.Accept (this), AssignmentExpression.RightExpressionRole);
 
1587
                                return result;
 
1588
                        }
 
1589
                        
 
1590
                        public override object Visit (CompoundAssign compoundAssign)
 
1591
                        {
 
1592
                                var result = new AssignmentExpression ();
 
1593
                                LocationDescriptor location = LocationStorage.Get (compoundAssign);
 
1594
                                int opLength = 2;
 
1595
                                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;
 
1628
                                }
 
1629
                                
 
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);
 
1633
                                return result;
 
1634
                        }
 
1635
                        
 
1636
                        public override object Visit (Mono.CSharp.AnonymousMethodExpression anonymousMethodExpression)
 
1637
                        {
 
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);
 
1641
                                
 
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);
 
1648
                                return result;
 
1649
                        }
 
1650
 
 
1651
                        public override object Visit (Mono.CSharp.LambdaExpression lambdaExpression)
 
1652
                        {
 
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
                        }
 
1674
                        #endregion
 
1675
                        
 
1676
                        #region LINQ expressions
 
1677
                        public override object Visit (Mono.CSharp.Linq.QueryExpression queryExpression)
 
1678
                        {
 
1679
                                var result = new QueryExpressionFromClause ();
 
1680
                                LocationDescriptor location = LocationStorage.Get (queryExpression);
 
1681
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "from".Length), QueryExpressionFromClause.FromKeywordRole);
 
1682
                                // 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);
 
1685
                                return result;
 
1686
                        }
 
1687
                        
 
1688
                        public override object Visit (Mono.CSharp.Linq.SelectMany selectMany)
 
1689
                        {
 
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);
 
1703
                                
 
1704
                                return result;
 
1705
                        }
 
1706
                        
 
1707
                        public override object Visit (Mono.CSharp.Linq.Select sel)
 
1708
                        {
 
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);
 
1713
                                return result;
 
1714
                        }
 
1715
                        
 
1716
                        public override object Visit (Mono.CSharp.Linq.GroupBy groupBy)
 
1717
                        {
 
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);
 
1724
                                return result;
 
1725
                        }
 
1726
                        
 
1727
                        public override object Visit (Mono.CSharp.Linq.Let l)
 
1728
                        {
 
1729
                                var result = new QueryExpressionLetClause ();
 
1730
                                LocationDescriptor location = LocationStorage.Get (l);
 
1731
                                
 
1732
                                result.AddChild (new CSharpTokenNode (Convert (location[0]), "let".Length), QueryExpressionWhereClause.Roles.Keyword);
 
1733
                                
 
1734
                                NewAnonymousType aType = l.Expr as NewAnonymousType;
 
1735
                                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);
 
1741
                                return result;
 
1742
                        }
 
1743
                        
 
1744
                        public override object Visit (Mono.CSharp.Linq.Where w)
 
1745
                        {
 
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);
 
1750
                                return result;
 
1751
                        }
 
1752
                        
 
1753
                        public override object Visit (Mono.CSharp.Linq.Join join)
 
1754
                        {
 
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);
 
1766
                                // TODO: on expression
 
1767
                                
 
1768
                                result.AddChild (new CSharpTokenNode (Convert (location[3]), "equals".Length), QueryExpressionJoinClause.EqualsKeywordRole);
 
1769
                                // TODO: equals expression
 
1770
                                
 
1771
                                return result;
 
1772
                        }
 
1773
                        
 
1774
                        public override object Visit (Mono.CSharp.Linq.GroupJoin groupJoin)
 
1775
                        {
 
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);
 
1787
                                // TODO: on expression
 
1788
                                
 
1789
                                result.AddChild (new CSharpTokenNode (Convert (location[3]), "equals".Length), QueryExpressionJoinClause.EqualsKeywordRole);
 
1790
                                // TODO: equals expression
 
1791
                                
 
1792
                                result.AddChild (new CSharpTokenNode (Convert (location[4]), "into".Length), QueryExpressionJoinClause.IntoKeywordRole);
 
1793
                                
 
1794
                                result.AddChild (new Identifier (groupJoin.IntoVariable.Value, Convert (groupJoin.IntoVariable.Location)));
 
1795
                                return result;
 
1796
                        }
 
1797
                        
 
1798
                        public override object Visit (Mono.CSharp.Linq.OrderByAscending orderByAscending)
 
1799
                        {
 
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);
 
1806
                                return result;
 
1807
                        }
 
1808
                        
 
1809
                        public override object Visit (Mono.CSharp.Linq.OrderByDescending orderByDescending)
 
1810
                        {
 
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);
 
1816
                                return result;
 
1817
                        }
 
1818
                        
 
1819
                        public override object Visit (Mono.CSharp.Linq.ThenByAscending thenByAscending)
 
1820
                        {
 
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);
 
1827
                                return result;
 
1828
                        }
 
1829
                        
 
1830
                        public override object Visit (Mono.CSharp.Linq.ThenByDescending thenByDescending)
 
1831
                        {
 
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);
 
1837
                                return result;
98
1838
                        }
99
1839
                        #endregion
100
1840
                }
101
1841
 
102
 
                public void Parse (string fileName)
 
1842
                public MonoDevelop.CSharp.Dom.CompilationUnit Parse (TextEditorData data)
103
1843
                {
104
 
                        ModuleContainer top;
105
 
                        using (FileStream fs = File.OpenRead (fileName)) {
106
 
                                top = CompilerCallableEntryPoint.ParseFile (new string[] { "-v"}, fs, fs.Name, Console.Out);
 
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);
107
1848
                        }
108
1849
 
109
1850
                        if (top == null)
110
 
                                return;
111
 
 
112
 
                        top.Accept (new Dumper ());
113
 
                        
 
1851
                                return null;
 
1852
                        CSharpParser.ConversionVisitor conversionVisitor = new ConversionVisitor (top.LocationStorage);
 
1853
                        top.ModuleCompiled.Accept (conversionVisitor);
 
1854
                        return conversionVisitor.Unit;
114
1855
                }
115
1856
        }
116
 
}
117
 
*/
 
 
b'\\ No newline at end of file'
 
1857
}*/