← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/core/MonoDevelop.Core/MonoDevelop.Projects.CodeGeneration/CodeRefactorer.cs

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/MonoDevelop.Core/MonoDevelop.Projects.CodeGeneration/CodeRefactorer.cs
269
269
                        return true;
270
270
                }
271
271
 
272
 
                public IMember AddMember (IType cls, CodeTypeMember member)
273
 
                {
274
 
                        RefactorerContext gctx = GetGeneratorContext (cls);
275
 
                        IRefactorer gen = GetGeneratorForClass (cls);
276
 
                        IMember m = gen.AddMember (gctx, cls, member);
277
 
                        gctx.Save ();
278
 
                        return m;
279
 
                }
280
 
                
281
 
                public IType AddMembers (IType cls, IEnumerable<CodeTypeMember> members, string foldingRegionName)
282
 
                {
283
 
                        RefactorerContext gctx = GetGeneratorContext (cls);
284
 
                        IRefactorer gen = GetGeneratorForClass (cls);
285
 
                        gen.AddMembers (gctx, cls, members, foldingRegionName);
286
 
                        gctx.Save ();
287
 
                        return GetUpdatedClass (gctx, cls);
288
 
                }
289
 
                
290
 
                public IMember ImplementMember (IType cls, IMember member, IReturnType privateReturnType)
291
 
                {
292
 
                        
293
 
                        RefactorerContext gctx = GetGeneratorContext (cls);
294
 
                        IRefactorer gen = GetGeneratorForClass (cls);
295
 
                        IMember m = gen.ImplementMember (gctx, cls, member, privateReturnType);
296
 
                        gctx.Save ();
297
 
                        return m;
298
 
                }
 
272
//              public IMember AddMember (IType cls, CodeTypeMember member)
 
273
//              {
 
274
//                      RefactorerContext gctx = GetGeneratorContext (cls);
 
275
//                      IRefactorer gen = GetGeneratorForClass (cls);
 
276
//                      IMember m = gen.AddMember (gctx, cls, member);
 
277
//                      gctx.Save ();
 
278
//                      return m;
 
279
//              }
 
280
//              
 
281
//              public IType AddMembers (IType cls, IEnumerable<CodeTypeMember> members, string foldingRegionName)
 
282
//              {
 
283
//                      RefactorerContext gctx = GetGeneratorContext (cls);
 
284
//                      IRefactorer gen = GetGeneratorForClass (cls);
 
285
//                      gen.AddMembers (gctx, cls, members, foldingRegionName);
 
286
//                      gctx.Save ();
 
287
//                      return GetUpdatedClass (gctx, cls);
 
288
//              }
 
289
                
 
290
//              public IMember ImplementMember (IType cls, IMember member, IReturnType privateReturnType)
 
291
//              {
 
292
//                      RefactorerContext gctx = GetGeneratorContext (cls);
 
293
//                      IRefactorer gen = GetGeneratorForClass (cls);
 
294
//                      IMember m = gen.ImplementMember (gctx, cls, member, privateReturnType);
 
295
//                      gctx.Save ();
 
296
//                      return m;
 
297
//              }
299
298
                
300
299
                public void AddGlobalNamespaceImport (ProjectDom dom, string fileName, string nsName)
301
300
                {
316
315
                        return refactorer.CompleteStatement (new RefactorerContext (dom, fileProvider, null), fileName, caretLocation);
317
316
                }
318
317
                
319
 
                public IType ImplementMembers (IType cls, IEnumerable<KeyValuePair<IMember,IReturnType>> members,
320
 
                                                              string foldingRegionName)
321
 
                {
322
 
                        RefactorerContext gctx = GetGeneratorContext (cls);
323
 
                        cls = GetUpdatedClass (gctx, cls);
324
 
                        IRefactorer gen = GetGeneratorForClass (cls);
325
 
                        gen.ImplementMembers (gctx, cls, members, foldingRegionName);
326
 
                        gctx.Save ();
327
 
                        return GetUpdatedClass (gctx, cls);
328
 
                }
 
318
//              public IType ImplementMembers (IType cls, IEnumerable<KeyValuePair<IMember,IReturnType>> members,
 
319
//                                                            string foldingRegionName)
 
320
//              {
 
321
//                      RefactorerContext gctx = GetGeneratorContext (cls);
 
322
//                      cls = GetUpdatedClass (gctx, cls);
 
323
//                      IRefactorer gen = GetGeneratorForClass (cls);
 
324
//                      gen.ImplementMembers (gctx, cls, members, foldingRegionName);
 
325
//                      gctx.Save ();
 
326
//                      return GetUpdatedClass (gctx, cls);
 
327
//              }
329
328
                
330
329
                string GenerateGenerics (IRefactorer gen, IType iface, IReturnType hintReturnType)
331
330
                {
375
374
                        return null;
376
375
                }
377
376
                
378
 
                public IType ImplementInterface (ICompilationUnit pinfo, IType klass, IType iface, bool explicitly, IType declaringClass, IReturnType hintReturnType)
379
 
                {
380
 
                        if (klass == null)
381
 
                                throw new ArgumentNullException ("klass");
382
 
                        if (iface == null)
383
 
                                throw new ArgumentNullException ("iface");
384
 
                        RefactorerContext gctx = GetGeneratorContext (klass);
385
 
                        klass = GetUpdatedClass (gctx, klass);
386
 
                        
387
 
                        bool alreadyImplemented;
388
 
                        IReturnType prefix = null;
389
 
                        
390
 
                        List<KeyValuePair<IMember,IReturnType>> toImplement = new List<KeyValuePair<IMember,IReturnType>> ();
391
 
                        
392
 
                        prefix = new DomReturnType (iface);
393
 
                        
394
 
                        // Stub out non-implemented events defined by @iface
395
 
                        foreach (IEvent ev in iface.Events) {
396
 
                                if (ev.IsSpecialName)
397
 
                                        continue;
398
 
                                bool needsExplicitly = explicitly;
399
 
                                
400
 
                                alreadyImplemented = gctx.ParserContext.GetInheritanceTree (klass).Any (x => x.ClassType != ClassType.Interface && x.Events.Any (y => y.Name == ev.Name));
401
 
                                
402
 
                                if (!alreadyImplemented)
403
 
                                        toImplement.Add (new KeyValuePair<IMember,IReturnType> (ev, needsExplicitly ? prefix : null));
404
 
                        }
405
 
                        
406
 
                        // Stub out non-implemented methods defined by @iface
407
 
                        foreach (IMethod method in iface.Methods) {
408
 
                                if (method.IsSpecialName)
409
 
                                        continue;
410
 
                                bool needsExplicitly = explicitly;
411
 
                                alreadyImplemented = false;
412
 
                                foreach (IType t in gctx.ParserContext.GetInheritanceTree (klass)) {
413
 
                                        if (t.ClassType == ClassType.Interface)
414
 
                                                continue;
415
 
                                        foreach (IMethod cmet in t.Methods) {
416
 
                                                if (cmet.Name == method.Name && Equals (cmet.Parameters, method.Parameters)) {
417
 
                                                        if (!needsExplicitly && !cmet.ReturnType.Equals (method.ReturnType))
418
 
                                                                needsExplicitly = true;
419
 
                                                        else
420
 
                                                                alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix (cmet.ExplicitInterfaces));
421
 
                                                }
422
 
                                        }
423
 
                                }
424
 
                                
425
 
                                if (!alreadyImplemented) 
426
 
                                        toImplement.Add (new KeyValuePair<IMember,IReturnType> (method, needsExplicitly ? prefix : null));
427
 
                        }
428
 
                        
429
 
                        // Stub out non-implemented properties defined by @iface
430
 
                        foreach (IProperty prop in iface.Properties) {
431
 
                                if (prop.IsSpecialName)
432
 
                                        continue;
433
 
                                bool needsExplicitly = explicitly;
434
 
                                alreadyImplemented = false;
435
 
                                foreach (IType t in gctx.ParserContext.GetInheritanceTree (klass)) {
436
 
                                        if (t.ClassType == ClassType.Interface)
437
 
                                                continue;
438
 
                                        foreach (IProperty cprop in t.Properties) {
439
 
                                                if (cprop.Name == prop.Name) {
440
 
                                                        if (!needsExplicitly && !cprop.ReturnType.Equals (prop.ReturnType))
441
 
                                                                needsExplicitly = true;
442
 
                                                        else
443
 
                                                                alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix (cprop.ExplicitInterfaces));
444
 
                                                }
445
 
                                        }
446
 
                                }
447
 
                                if (!alreadyImplemented)
448
 
                                        toImplement.Add (new KeyValuePair<IMember,IReturnType> (prop, needsExplicitly ? prefix : null));                                }
449
 
                        
450
 
                        Ambience ambience = AmbienceService.GetAmbienceForFile (klass.CompilationUnit.FileName);
451
 
                        //implement members
452
 
                        ImplementMembers (klass, toImplement, ambience.GetString (iface, OutputFlags.ClassBrowserEntries | OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters) +  " implementation");
453
 
                        gctx.Save ();
454
 
                        
455
 
                        klass = GetUpdatedClass (gctx, klass);
456
 
                        foreach (IType baseClass in iface.SourceProjectDom.GetInheritanceTree (iface)) {
457
 
                                if (baseClass.Equals (iface) || baseClass.FullName == "System.Object")
458
 
                                        continue;
459
 
                                klass = ImplementInterface (pinfo, klass, baseClass, explicitly, declaringClass, hintReturnType);
460
 
                        }
461
 
                        
462
 
                        
463
 
                        return klass;
464
 
                }
 
377
//              public IType ImplementInterface (ICompilationUnit pinfo, IType klass, IType iface, bool explicitly, IType declaringClass, IReturnType hintReturnType)
 
378
//              {
 
379
//                      if (klass == null)
 
380
//                              throw new ArgumentNullException ("klass");
 
381
//                      if (iface == null)
 
382
//                              throw new ArgumentNullException ("iface");
 
383
//                      RefactorerContext gctx = GetGeneratorContext (klass);
 
384
//                      klass = GetUpdatedClass (gctx, klass);
 
385
//                      
 
386
//                      bool alreadyImplemented;
 
387
//                      IReturnType prefix = null;
 
388
//                      
 
389
//                      List<KeyValuePair<IMember,IReturnType>> toImplement = new List<KeyValuePair<IMember,IReturnType>> ();
 
390
//                      
 
391
//                      prefix = new DomReturnType (iface);
 
392
//                      
 
393
//                      // Stub out non-implemented events defined by @iface
 
394
//                      foreach (IEvent ev in iface.Events) {
 
395
//                              if (ev.IsSpecialName)
 
396
//                                      continue;
 
397
//                              bool needsExplicitly = explicitly;
 
398
//                              
 
399
//                              alreadyImplemented = gctx.ParserContext.GetInheritanceTree (klass).Any (x => x.ClassType != ClassType.Interface && x.Events.Any (y => y.Name == ev.Name));
 
400
//                              
 
401
//                              if (!alreadyImplemented)
 
402
//                                      toImplement.Add (new KeyValuePair<IMember,IReturnType> (ev, needsExplicitly ? prefix : null));
 
403
//                      }
 
404
//                      
 
405
//                      // Stub out non-implemented methods defined by @iface
 
406
//                      foreach (IMethod method in iface.Methods) {
 
407
//                              if (method.IsSpecialName)
 
408
//                                      continue;
 
409
//                              bool needsExplicitly = explicitly;
 
410
//                              alreadyImplemented = false;
 
411
//                              foreach (IType t in gctx.ParserContext.GetInheritanceTree (klass)) {
 
412
//                                      if (t.ClassType == ClassType.Interface)
 
413
//                                              continue;
 
414
//                                      foreach (IMethod cmet in t.Methods) {
 
415
//                                              if (cmet.Name == method.Name && Equals (cmet.Parameters, method.Parameters)) {
 
416
//                                                      if (!needsExplicitly && !cmet.ReturnType.Equals (method.ReturnType))
 
417
//                                                              needsExplicitly = true;
 
418
//                                                      else
 
419
//                                                              alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix (cmet.ExplicitInterfaces));
 
420
//                                              }
 
421
//                                      }
 
422
//                              }
 
423
//                              
 
424
//                              if (!alreadyImplemented) 
 
425
//                                      toImplement.Add (new KeyValuePair<IMember,IReturnType> (method, needsExplicitly ? prefix : null));
 
426
//                      }
 
427
//                      
 
428
//                      // Stub out non-implemented properties defined by @iface
 
429
//                      foreach (IProperty prop in iface.Properties) {
 
430
//                              if (prop.IsSpecialName)
 
431
//                                      continue;
 
432
//                              bool needsExplicitly = explicitly;
 
433
//                              alreadyImplemented = false;
 
434
//                              foreach (IType t in gctx.ParserContext.GetInheritanceTree (klass)) {
 
435
//                                      if (t.ClassType == ClassType.Interface)
 
436
//                                              continue;
 
437
//                                      foreach (IProperty cprop in t.Properties) {
 
438
//                                              if (cprop.Name == prop.Name) {
 
439
//                                                      if (!needsExplicitly && !cprop.ReturnType.Equals (prop.ReturnType))
 
440
//                                                              needsExplicitly = true;
 
441
//                                                      else
 
442
//                                                              alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix (cprop.ExplicitInterfaces));
 
443
//                                              }
 
444
//                                      }
 
445
//                              }
 
446
//                              if (!alreadyImplemented)
 
447
//                                      toImplement.Add (new KeyValuePair<IMember,IReturnType> (prop, needsExplicitly ? prefix : null));                                }
 
448
//                      
 
449
//                      Ambience ambience = AmbienceService.GetAmbienceForFile (klass.CompilationUnit.FileName);
 
450
//                      //implement members
 
451
//                      ImplementMembers (klass, toImplement, ambience.GetString (iface, OutputFlags.ClassBrowserEntries | OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters) +  " implementation");
 
452
//                      gctx.Save ();
 
453
//                      
 
454
//                      klass = GetUpdatedClass (gctx, klass);
 
455
//                      foreach (IType baseClass in iface.SourceProjectDom.GetInheritanceTree (iface)) {
 
456
//                              if (baseClass.Equals (iface) || baseClass.FullName == "System.Object")
 
457
//                                      continue;
 
458
//                              klass = ImplementInterface (pinfo, klass, baseClass, explicitly, declaringClass, hintReturnType);
 
459
//                      }
 
460
//                      
 
461
//                      
 
462
//                      return klass;
 
463
//              }
465
464
                
466
465
                IType GetUpdatedClass (RefactorerContext gctx, IType klass)
467
466
                {
468
467
                        IEditableTextFile file = gctx.GetFile (klass.CompilationUnit.FileName);
469
 
                        ParsedDocument doc = ProjectDomService.Parse (gctx.ParserContext.Project, file.Name, null, delegate () { return file.Text; });
 
468
                        ParsedDocument doc = ProjectDomService.Parse (gctx.ParserContext.Project, file.Name, delegate () { return file.Text; });
470
469
                        IType result = gctx.ParserContext.GetType (klass.FullName, klass.TypeParameters.Count, true);
471
470
                        if (result is CompoundType) {
472
471
                                IType hintType = doc.CompilationUnit.GetType (klass.FullName, klass.TypeParameters.Count);
571
570
                        }
572
571
                }
573
572
                
574
 
                public bool RenameVariable (IProgressMonitor monitor, LocalVariable var, string newName)
575
 
                {
576
 
                        try {
577
 
                                MemberReferenceCollection refs = new MemberReferenceCollection ();
578
 
                                Refactor (monitor, var, new RefactorDelegate (new RefactorFindVariableReferences (var, refs).Refactor));
579
 
                                refs.RenameAll (newName);
580
 
                                
581
 
                                RefactorerContext gctx = GetGeneratorContext (var);
582
 
                                IRefactorer r = GetGeneratorForVariable (var);
583
 
                                bool rv = r.RenameVariable (gctx, var, newName);
584
 
                                gctx.Save ();
585
 
                                
586
 
                                return rv;
587
 
                        } catch (Exception e) {
588
 
                                LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}",  var, newName, e.ToString ()));
589
 
                                return false;
590
 
                        }
591
 
                }
592
 
                
593
 
                public bool RenameParameter (IProgressMonitor monitor, IParameter param, string newName)
594
 
                {
595
 
                        try {
596
 
                                MemberReferenceCollection refs = new MemberReferenceCollection ();
597
 
                                Refactor (monitor, param, new RefactorDelegate (new RefactorFindParameterReferences (param, refs, false).Refactor));
598
 
                                refs.RenameAll (newName);
599
 
                                
600
 
                                IMember member = param.DeclaringMember;
601
 
                                RefactorerContext gctx = GetGeneratorContext (member.DeclaringType);
602
 
                                IRefactorer r = GetGeneratorForClass (member.DeclaringType);
603
 
                                bool rv = r.RenameParameter (gctx, param, newName);
604
 
                                gctx.Save ();
605
 
                                
606
 
                                return rv;
607
 
                        } catch (Exception e) {
608
 
                                LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}",  param, newName, e.ToString ()));
609
 
                                return false;
610
 
                        }
611
 
                }
612
 
                
613
 
                public IMember EncapsulateField (IProgressMonitor monitor, IType cls, IField field, string propName, MemberAttributes attr, bool generateSetter, bool updateInternalRefs)
614
 
                {
615
 
                        RefactoryScope scope = GetScope (field);
616
 
                        
617
 
                        MemberReferenceCollection refs = new MemberReferenceCollection ();
618
 
                        Refactor (monitor, cls, scope, new RefactorDelegate (new RefactorFindMemberReferences (cls, field, refs, false).Refactor));
619
 
                        
620
 
                        if (!updateInternalRefs) {
621
 
                                ArrayList list = new ArrayList ();
622
 
                                list.AddRange (refs);
623
 
                                list.Sort (new MemberReferenceCollection.MemberComparer ());
624
 
                                
625
 
                                foreach (MemberReference mref in list) {
626
 
                                        bool rename = true;
627
 
                                        foreach (IType part in field.DeclaringType.Parts) {
628
 
                                                if (mref.FileName == part.CompilationUnit.FileName) {
629
 
                                                        DomRegion region = part.BodyRegion;
630
 
                                                        
631
 
                                                        // check if the reference is internal to the class
632
 
                                                        if ((mref.Line > region.Start.Line ||
633
 
                                                             (mref.Line == region.Start.Line && mref.Column >= region.Start.Column)) &&
634
 
                                                            (mref.Line < region.End.Line ||
635
 
                                                             (mref.Line == region.End.Line && mref.Column <= region.End.Column))) {
636
 
                                                                // Internal to the class, don't rename
637
 
                                                                rename = false;
638
 
                                                                break;
639
 
                                                        }
640
 
                                                }
641
 
                                        }
642
 
                                        
643
 
                                        if (rename)
644
 
                                                mref.Rename (propName);
645
 
                                }
646
 
                        } else {
647
 
                                refs.RenameAll (propName);
648
 
                        }
649
 
                        
650
 
                        RefactorerContext gctx = GetGeneratorContext (cls);
651
 
                        IRefactorer r = GetGeneratorForClass (cls);
652
 
                        IMember m = r.EncapsulateField (gctx, cls, field, propName, attr, generateSetter);
653
 
                        gctx.Save ();
654
 
                        
655
 
                        return m;
656
 
                }
 
573
//              public bool RenameVariable (IProgressMonitor monitor, LocalVariable var, string newName)
 
574
//              {
 
575
//                      try {
 
576
//                              MemberReferenceCollection refs = new MemberReferenceCollection ();
 
577
//                              Refactor (monitor, var, new RefactorDelegate (new RefactorFindVariableReferences (var, refs).Refactor));
 
578
//                              refs.RenameAll (newName);
 
579
//                              
 
580
//                              RefactorerContext gctx = GetGeneratorContext (var);
 
581
//                              IRefactorer r = GetGeneratorForVariable (var);
 
582
//                              bool rv = r.RenameVariable (gctx, var, newName);
 
583
//                              gctx.Save ();
 
584
//                              
 
585
//                              return rv;
 
586
//                      } catch (Exception e) {
 
587
//                              LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}",  var, newName, e.ToString ()));
 
588
//                              return false;
 
589
//                      }
 
590
//              }
 
591
//              
 
592
//              public bool RenameParameter (IProgressMonitor monitor, IParameter param, string newName)
 
593
//              {
 
594
//                      try {
 
595
//                              MemberReferenceCollection refs = new MemberReferenceCollection ();
 
596
//                              Refactor (monitor, param, new RefactorDelegate (new RefactorFindParameterReferences (param, refs, false).Refactor));
 
597
//                              refs.RenameAll (newName);
 
598
//                              
 
599
//                              IMember member = param.DeclaringMember;
 
600
//                              RefactorerContext gctx = GetGeneratorContext (member.DeclaringType);
 
601
//                              IRefactorer r = GetGeneratorForClass (member.DeclaringType);
 
602
//                              bool rv = r.RenameParameter (gctx, param, newName);
 
603
//                              gctx.Save ();
 
604
//                              
 
605
//                              return rv;
 
606
//                      } catch (Exception e) {
 
607
//                              LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}",  param, newName, e.ToString ()));
 
608
//                              return false;
 
609
//                      }
 
610
//              }
657
611
                
658
612
                public IType[] FindDerivedClasses (IType baseClass)
659
613
                {