← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/addins/CSharpBinding/MonoDevelop.CSharp.Refactoring/CSharpCodeGenerator.cs

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/CSharpBinding/MonoDevelop.CSharp.Refactoring/CSharpCodeGenerator.cs
42
42
using ICSharpCode.Decompiler;
43
43
using ICSharpCode.Decompiler.Ast;
44
44
using ICSharpCode.NRefactory.PatternMatching;
 
45
using ICSharpCode.NRefactory.TypeSystem.Implementation;
45
46
 
46
47
 
47
48
namespace MonoDevelop.CSharp.Refactoring
55
56
                public MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy Policy {
56
57
                        get {
57
58
                                if (policy == null) {
58
 
                                        var types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType);
 
59
                                        var types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (MonoDevelop.CSharp.Formatting.CSharpFormatter.MimeType);
59
60
                                        if (PolicyParent != null)
60
61
                                                policy = PolicyParent.Get<CSharpFormattingPolicy> (types);
61
62
                                        if (policy == null) {
73
74
                        }
74
75
                        set {
75
76
                                base.PolicyParent = value;
76
 
                                var types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (CSharpFormatter.MimeType);
 
77
                                var types = MonoDevelop.Ide.DesktopService.GetMimeTypeInheritanceChain (MonoDevelop.CSharp.Formatting.CSharpFormatter.MimeType);
77
78
                                policy = value.Get<CSharpFormattingPolicy> (types);
78
79
                        }
79
80
                }
84
85
                        public bool ExplicitDeclaration { get; set; }
85
86
                        public ITypeDefinition ImplementingType { get; set; }
86
87
                        public IUnresolvedTypeDefinition Part { get; set; }
 
88
 
 
89
                        public MonoDevelop.Ide.Gui.Document Document { get; set; }
 
90
 
 
91
                        public string GetShortType (string ns, string name, int typeArguments = 0)
 
92
                        {
 
93
                                if (Document == null || Document.ParsedDocument == null)
 
94
                                        return ns + "." + name;
 
95
                                var typeDef = new GetClassTypeReference (ns, name, typeArguments).Resolve (Document.Compilation.TypeResolveContext);
 
96
                                if (typeDef == null)
 
97
                                        return ns + "." + name;
 
98
                                var file = Document.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
 
99
                                var csResolver = file.GetResolver (Document.Compilation, Document.Editor.Caret.Location);
 
100
                                var builder = new ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder (csResolver);
 
101
                                return OutputNode (Document, builder.ConvertType (typeDef));
 
102
                        }
87
103
                }
88
104
                
89
105
                public override string WrapInRegions (string regionName, string text)
99
115
                        result.Append ("#endregion");
100
116
                        return result.ToString ();
101
117
                }
 
118
 
 
119
                void AppendObsoleteAttribute (StringBuilder result, CodeGenerationOptions options, IEntity entity)
 
120
                {
 
121
                        string reason;
 
122
                        if (!entity.IsObsolete (out reason))
 
123
                                return;
 
124
 
 
125
                        var implementingType = options.Part;
 
126
                        var loc = implementingType.Region.End;
 
127
                        
 
128
                        var pf = implementingType.UnresolvedFile;
 
129
                        var file = pf as CSharpUnresolvedFile;
 
130
 
 
131
                        result.Append ("[");
 
132
                        var obsoleteRef = ReflectionHelper.ParseReflectionName ("System.ObsoleteAttribute");
 
133
                        var resolvedType = obsoleteRef.Resolve (options.ImplementingType.Compilation);
 
134
                        var shortType = resolvedType.Kind != TypeKind.Unknown ? CreateShortType (options.ImplementingType.Compilation, file, loc, resolvedType) : null;
 
135
                        var text = shortType != null ? shortType.ToString () : "System.Obsolete";
 
136
                        if (text.EndsWith ("Attribute", StringComparison.Ordinal))
 
137
                                text = text.Substring (0, text.Length - "Attribute".Length);
 
138
                        result.Append (text);
 
139
                        if (!string.IsNullOrEmpty (reason)) {
 
140
                                result.Append (" (\"");
 
141
                                result.Append (reason);
 
142
                                result.Append ("\")");
 
143
                        }
 
144
                        result.Append ("]");
 
145
                        result.AppendLine ();
 
146
                }
102
147
                
103
148
                public override CodeGeneratorMemberResult CreateMemberImplementation (ITypeDefinition implementingType,
104
149
                                                                                      IUnresolvedTypeDefinition part,
113
158
                        };
114
159
                        ITypeResolveContext ctx;
115
160
 
116
 
                        var doc = IdeApp.Workbench.GetDocument (implementingType.Region.FileName);
117
 
                        if (doc != null) {
118
 
                                ctx = doc.ParsedDocument.GetTypeResolveContext (doc.Compilation, implementingType.Region.Begin);
119
 
                        } else {
120
 
                                ctx = new CSharpTypeResolveContext (implementingType.Compilation.MainAssembly, null, implementingType, null);
121
 
                        }
 
161
                        var doc = IdeApp.Workbench.GetDocument (part.Region.FileName);
 
162
                        ctx = new CSharpTypeResolveContext (implementingType.Compilation.MainAssembly, null, implementingType, null);
 
163
                        options.Document = doc;
122
164
 
123
165
                        if (member is IUnresolvedMethod)
124
166
                                return GenerateCode ((IMethod) ((IUnresolvedMethod)member).CreateResolved (ctx), options);
140
182
                        var options = new CodeGenerationOptions () {
141
183
                                ExplicitDeclaration = explicitDeclaration,
142
184
                                ImplementingType = implementingType,
143
 
                                Part = part
 
185
                                Part = part,
 
186
                                Document = IdeApp.Workbench.GetDocument (part.Region.FileName)
144
187
                        };
145
188
                        if (member is IMethod)
146
189
                                return GenerateCode ((IMethod)member, options);
229
272
                        var implementingType = options.Part;
230
273
                        var loc = implementingType.Region.End;
231
274
                        
232
 
                        var pf = implementingType.ParsedFile;
233
 
                        var file = pf as CSharpParsedFile;
 
275
                        var pf = implementingType.UnresolvedFile;
 
276
                        var file = pf as CSharpUnresolvedFile;
234
277
                        var resolved = type;
235
278
                        if (resolved.Kind == TypeKind.Unknown) {
236
279
                                result.Append (type.FullName);
278
321
                        result.Append (" ");
279
322
                        AppendReturnType (result, options, field.ReturnType);
280
323
                        result.Append (" ");
281
 
                        result.Append (field.Name);
 
324
                        result.Append (CSharpAmbience.FilterName (field.Name));
282
325
                        result.Append (";");
283
326
                        return new CodeGeneratorMemberResult (result.ToString (), -1, -1);
284
327
                }
286
329
                CodeGeneratorMemberResult GenerateCode (IEvent evt, CodeGenerationOptions options)
287
330
                {
288
331
                        StringBuilder result = new StringBuilder ();
289
 
                        
 
332
                        AppendObsoleteAttribute (result, options, evt);
290
333
                        AppendModifiers (result, options, evt);
291
334
                        
292
335
                        result.Append ("event ");
296
339
                                result.Append (ambience.GetString (evt.DeclaringTypeDefinition, OutputFlags.IncludeGenerics));
297
340
                                result.Append (".");
298
341
                        }
299
 
                        result.Append (evt.Name);
 
342
                        result.Append (CSharpAmbience.FilterName (evt.Name));
300
343
                        if (options.ExplicitDeclaration) {
301
344
                                AppendBraceStart (result, Policy.EventBraceStyle);
302
345
                                AppendIndent (result);
328
371
                        AppendIndent (result);
329
372
                        bodyStartOffset = result.Length;
330
373
                        result.Append ("throw new ");
331
 
                        // TODO: Type system conversion.
332
 
                        result.Append ("System.NotImplementedException");
333
 
//                      AppendReturnType (result, options.ImplementingType, options.Ctx.GetTypeDefinition (typeof (System.NotImplementedException)));
 
374
                        result.Append (options.GetShortType ("System", "NotImplementedException"));
 
375
                        //                      AppendReturnType (result, options.ImplementingType, options.Ctx.GetTypeDefinition (typeof (System.NotImplementedException)));
334
376
                        if (Policy.BeforeMethodCallParentheses)
335
377
                                result.Append (" ");
336
378
                        result.Append ("();");
338
380
                        AppendLine (result);
339
381
                }
340
382
                
341
 
                void AppendMonoTouchTodo (StringBuilder result, out int bodyStartOffset, out int bodyEndOffset)
 
383
                void AppendMonoTouchTodo (StringBuilder result, CodeGenerationOptions options, out int bodyStartOffset, out int bodyEndOffset)
342
384
                {
343
385
                        AppendIndent (result);
344
386
                        bodyStartOffset = result.Length;
345
 
                        result.Append ("// TODO: Implement - see: http://go-mono.com/docs/index.aspx?link=T%3aMonoTouch.Foundation.ModelAttribute");
 
387
                        result.AppendLine ("// NOTE: Don't call the base implementation on a Model class");
 
388
                        
 
389
                        AppendIndent (result);
 
390
                        result.AppendLine ("// see http://docs.xamarin.com/ios/tutorials/Events%2c_Protocols_and_Delegates ");
 
391
 
 
392
                        AppendIndent (result);
 
393
                        result.Append ("throw new ");
 
394
                        result.Append (options.GetShortType ("System", "NotImplementedException"));
 
395
 
 
396
                        if (Policy.BeforeMethodCallParentheses)
 
397
                                result.Append (" ");
 
398
                        result.Append ("();");
 
399
 
346
400
                        bodyEndOffset = result.Length;
347
401
                        AppendLine (result);
348
402
                }
351
405
                {
352
406
                        int bodyStartOffset = -1, bodyEndOffset = -1;
353
407
                        StringBuilder result = new StringBuilder ();
 
408
                        AppendObsoleteAttribute (result, options, method);
354
409
                        AppendModifiers (result, options, method);
 
410
                        if (method.IsPartial)
 
411
                                result.Append ("partial ");
355
412
                        AppendReturnType (result, options, method.ReturnType);
356
413
                        result.Append (" ");
357
414
                        if (options.ExplicitDeclaration) {
358
415
                                AppendReturnType (result, options, method.DeclaringType);
359
416
                                result.Append (".");
360
417
                        }
361
 
                        result.Append (method.Name);
 
418
 
 
419
                        result.Append (CSharpAmbience.FilterName (method.Name));
362
420
                        if (method.TypeParameters.Count > 0) {
363
421
                                result.Append ("<");
364
422
                                for (int i = 0; i < method.TypeParameters.Count; i++) {
365
423
                                        if (i > 0)
366
424
                                                result.Append (", ");
367
425
                                        var p = method.TypeParameters [i];
368
 
                                        result.Append (p.Name);
 
426
                                        result.Append (CSharpAmbience.FilterName (p.Name));
369
427
                                }
370
428
                                result.Append (">");
371
429
                        }
390
448
                                                result.Append (", ");
391
449
                                        
392
450
                                        typeParameterCount++;
393
 
                                        result.Append (p.Name);
 
451
                                        result.Append (CSharpAmbience.FilterName (p.Name));
394
452
                                        result.Append (" : ");
395
453
                                        int constraintCount = 0;
396
454
                                        
460
518
                                        bodyEndOffset = result.Length;
461
519
                                        AppendLine (result);
462
520
                                } else if (IsMonoTouchModelMember (method)) {
463
 
                                        AppendMonoTouchTodo (result, out bodyStartOffset, out bodyEndOffset);
 
521
                                        AppendMonoTouchTodo (result, options, out bodyStartOffset, out bodyEndOffset);
464
522
                                } else if (method.IsAbstract || !(method.IsVirtual || method.IsOverride) || method.DeclaringTypeDefinition.Kind == TypeKind.Interface) {
465
523
                                        AppendNotImplementedException (result, options, out bodyStartOffset, out bodyEndOffset);
466
524
                                } else {
512
570
                                                if (method.ReturnType.ReflectionName != typeof(void).FullName)
513
571
                                                        result.Append ("return ");
514
572
                                                result.Append ("base.");
515
 
                                                result.Append (method.Name);
 
573
                                                result.Append (CSharpAmbience.FilterName (method.Name));
516
574
                                                if (Policy.BeforeMethodCallParentheses)
517
575
                                                        result.Append (" ");
518
576
                                                result.Append ("(");
525
583
                                                                result.Append ("out ");
526
584
                                                        if (p.IsRef)
527
585
                                                                result.Append ("ref ");
528
 
                                                        result.Append (p.Name);
 
586
                                                        result.Append (CSharpAmbience.FilterName (p.Name));
529
587
                                                }
530
588
                                                result.Append (");");
531
589
                                        } else {
565
623
                                        result.Append ("params ");
566
624
                                AppendReturnType (result, options, p.Type);
567
625
                                result.Append (" ");
568
 
                                result.Append (p.Name);
 
626
                                result.Append (CSharpAmbience.FilterName (p.Name));
569
627
                        }
570
628
                }
571
629
                
605
663
                        if (options.ExplicitDeclaration || options.ImplementingType.Kind == TypeKind.Interface)
606
664
                                return;
607
665
                        result.Append (GetModifiers (options.ImplementingType, options.Part, member));
608
 
                        
609
666
                        bool isFromInterface = false;
610
667
                        if (member.DeclaringType != null && member.DeclaringTypeDefinition.Kind == TypeKind.Interface) {
611
668
                                isFromInterface = true;
621
678
//                                      }
622
679
//                              }
623
680
                        }
624
 
                        
 
681
 
625
682
                        if (!isFromInterface && member.IsOverridable)
626
683
                                result.Append ("override ");
 
684
                        if (member is IMethod && ((IMethod)member).IsAsync)
 
685
                                result.Append ("async ");
627
686
                }
628
687
                
629
688
                CodeGeneratorMemberResult GenerateCode (IProperty property, CodeGenerationOptions options)
630
689
                {
631
690
                        var regions = new List<CodeGeneratorBodyRegion> ();
632
691
                        var result = new StringBuilder ();
 
692
                        AppendObsoleteAttribute (result, options, property);
633
693
                        AppendModifiers (result, options, property);
634
694
                        AppendReturnType (result, options, property.ReturnType);
635
695
                        result.Append (" ");
642
702
                                        result.Append (ambience.GetString (property.DeclaringType, OutputFlags.IncludeGenerics));
643
703
                                        result.Append (".");
644
704
                                }
645
 
                                result.Append (property.Name);
 
705
                                result.Append (CSharpAmbience.FilterName (property.Name));
646
706
                        }
647
707
                        AppendBraceStart (result, Policy.PropertyBraceStyle);
648
708
                        if (property.CanGet) {
654
714
                                } else {
655
715
                                        AppendBraceStart (result, Policy.PropertyGetBraceStyle);
656
716
                                        if (IsMonoTouchModelMember (property)) {
657
 
                                                AppendMonoTouchTodo (result, out bodyStartOffset, out bodyEndOffset);
 
717
                                                AppendMonoTouchTodo (result, options, out bodyStartOffset, out bodyEndOffset);
658
718
                                        } else if (property.IsAbstract || property.DeclaringTypeDefinition.Kind == TypeKind.Interface) {
659
719
                                                AppendNotImplementedException (result, options, out bodyStartOffset, out bodyEndOffset);
660
720
                                        } else {
663
723
                                                if (property.EntityType == EntityType.Indexer) {
664
724
                                                        result.Append ("return base[");
665
725
                                                        if (property.Parameters.Count > 0)
666
 
                                                                result.Append (property.Parameters.First ().Name);
 
726
                                                                result.Append (CSharpAmbience.FilterName (property.Parameters.First ().Name));
667
727
                                                        result.Append ("];");
668
728
                                                } else {
669
729
                                                        result.Append ("return base.");
670
 
                                                        result.Append (property.Name);
 
730
                                                        result.Append (CSharpAmbience.FilterName (property.Name));
671
731
                                                        result.Append (";");
672
732
                                                }
673
733
                                                bodyEndOffset = result.Length;
688
748
                                } else {
689
749
                                        AppendBraceStart (result, Policy.PropertyGetBraceStyle);
690
750
                                        if (IsMonoTouchModelMember (property)) {
691
 
                                                AppendMonoTouchTodo (result, out bodyStartOffset, out bodyEndOffset);
 
751
                                                AppendMonoTouchTodo (result, options, out bodyStartOffset, out bodyEndOffset);
692
752
                                        } else if (property.IsAbstract || property.DeclaringTypeDefinition.Kind == TypeKind.Interface) {
693
753
                                                AppendNotImplementedException (result, options, out bodyStartOffset, out bodyEndOffset);
694
754
                                        } else {
697
757
                                                if (property.EntityType == EntityType.Indexer) {
698
758
                                                        result.Append ("base[");
699
759
                                                        if (property.Parameters.Count > 0)
700
 
                                                                result.Append (property.Parameters.First ().Name);
 
760
                                                                result.Append (CSharpAmbience.FilterName (property.Parameters.First ().Name));
701
761
                                                        result.Append ("] = value;");
702
762
                                                } else { 
703
763
                                                        result.Append ("base.");
704
 
                                                        result.Append (property.Name);
 
764
                                                        result.Append (CSharpAmbience.FilterName (property.Name));
705
765
                                                        result.Append (" = value;");
706
766
                                                }
707
767
                                                bodyEndOffset = result.Length;
739
799
                                ImplementingType = field.DeclaringTypeDefinition,
740
800
                                Part = implementingType
741
801
                        };
742
 
                        
 
802
                        result.Append ("public ");
743
803
                        AppendReturnType (result, options, field.ReturnType);
744
804
                        result.Append (" ");
745
805
                        result.Append (propertyName);
750
810
                        AppendBraceStart (result, Policy.PropertyGetBraceStyle);
751
811
                        AppendIndent (result);
752
812
                        result.Append ("return this.");
753
 
                        result.Append (field.Name);
 
813
                        result.Append (CSharpAmbience.FilterName (field.Name));
754
814
                        result.Append (";");
755
815
                        AppendLine (result);
756
816
                        AppendBraceEnd (result, Policy.PropertyGetBraceStyle);
761
821
                                result.Append ("set");
762
822
                                AppendBraceStart (result, Policy.PropertyGetBraceStyle);
763
823
                                AppendIndent (result);
764
 
                                result.Append (field.Name);
 
824
                                result.Append (CSharpAmbience.FilterName (field.Name));
765
825
                                result.Append (" = value;");
766
826
                                AppendLine (result);
767
827
                                AppendBraceEnd (result, Policy.PropertyGetBraceStyle);
785
845
                
786
846
                static bool InsertUsingAfter (AstNode node)
787
847
                {
 
848
                        return node is NewLineNode && IsCommentOrUsing (node.GetNextSibling (s => !(s is NewLineNode))) ||
 
849
                                IsCommentOrUsing (node);
 
850
                }
 
851
 
 
852
                static bool IsCommentOrUsing (AstNode node)
 
853
                {
788
854
                        return node is ICSharpCode.NRefactory.CSharp.Comment ||
789
855
                                node is UsingDeclaration ||
790
856
                                node is UsingAliasDeclaration;
805
871
                public override void AddGlobalNamespaceImport (MonoDevelop.Ide.Gui.Document doc, string nsName)
806
872
                {
807
873
                        var parsedDocument = doc.ParsedDocument;
808
 
                        var unit = parsedDocument.GetAst<CompilationUnit> ();
 
874
                        var unit = parsedDocument.GetAst<SyntaxTree> ();
809
875
                        if (unit == null)
810
876
                                return;
811
877
                        
849
915
                public override void AddLocalNamespaceImport (MonoDevelop.Ide.Gui.Document doc, string nsName, TextLocation caretLocation)
850
916
                {
851
917
                        var parsedDocument = doc.ParsedDocument;
852
 
                        var unit = parsedDocument.GetAst<CompilationUnit> ();
 
918
                        var unit = parsedDocument.GetAst<SyntaxTree> ();
853
919
                        if (unit == null)
854
920
                                return;
855
921
                        
904
970
                
905
971
                public override string GetShortTypeString (MonoDevelop.Ide.Gui.Document doc, IType type)
906
972
                {
907
 
                        var shortType = CreateShortType (doc.Compilation, doc.ParsedDocument.ParsedFile as CSharpParsedFile, doc.Editor.Caret.Location, type);
 
973
                        var shortType = CreateShortType (doc.Compilation, doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile, doc.Editor.Caret.Location, type);
908
974
                        return OutputNode (doc, shortType);
909
975
                }
910
976
                
922
988
                }
923
989
                
924
990
                
925
 
                public AstType CreateShortType (ICompilation compilation, CSharpParsedFile parsedFile, TextLocation loc, IType fullType)
 
991
                public AstType CreateShortType (ICompilation compilation, CSharpUnresolvedFile parsedFile, TextLocation loc, IType fullType)
926
992
                {
927
993
                        var csResolver = parsedFile.GetResolver (compilation, loc);
928
994
                        var builder = new ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder (csResolver);