← 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/CSharpEnhancedCodeProvider.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/CSharpEnhancedCodeProvider.cs
34
34
using System.CodeDom;
35
35
using System.CodeDom.Compiler;
36
36
using Microsoft.CSharp;
37
 
using ICSharpCode.OldNRefactory;
38
 
using ICSharpCode.OldNRefactory.Parser;
39
 
using ICSharpCode.OldNRefactory.Visitors;
 
37
using ICSharpCode.NRefactory.CSharp;
 
38
using Mono.Cecil;
 
39
using MonoDevelop.Ide.TypeSystem;
 
40
using ICSharpCode.NRefactory.TypeSystem;
40
41
 
41
42
namespace MonoDevelop.CSharp
42
43
{
58
59
                        return ParseInternal (codeStream);
59
60
                }
60
61
                
 
62
                static readonly Lazy<IUnresolvedAssembly> mscorlib = new Lazy<IUnresolvedAssembly>(
 
63
                        delegate {
 
64
                        return new CecilLoader().LoadAssemblyFile(typeof(object).Assembly.Location);
 
65
                });
 
66
                
 
67
                static readonly Lazy<IUnresolvedAssembly> systemCore = new Lazy<IUnresolvedAssembly>(
 
68
                        delegate {
 
69
                        return new CecilLoader().LoadAssemblyFile(typeof(System.Linq.Enumerable).Assembly.Location);
 
70
                });
 
71
 
 
72
                static readonly Lazy<ICompilation> Compilation = new Lazy<ICompilation>(
 
73
                        delegate {
 
74
                                var project = new CSharpProjectContent().AddAssemblyReferences (new [] { mscorlib.Value, systemCore.Value });
 
75
                                return project.CreateCompilation();
 
76
                });
 
77
 
61
78
                static CodeCompileUnit ParseInternal (TextReader codeStream)
62
79
                {
63
 
                        IParser parser = ParserFactory.CreateParser (
64
 
                                SupportedLanguage.CSharp,
65
 
                                codeStream);
66
 
                        parser.ParseMethodBodies = true;
67
 
                        parser.Parse ();
68
 
                        
69
 
                        if (parser.Errors.Count > 0)
70
 
                                throw new ArgumentException (parser.Errors.ErrorOutput);
71
 
                        
72
 
                        var cdv = new CodeDomVisitor (); // new CodeDomVisitor (parser.Lexer.SpecialTracker.CurrentSpecials);
73
 
                        parser.CompilationUnit.AcceptVisitor (cdv, null);
74
 
                        
75
 
                        parser.Dispose ();
76
 
                        
77
 
                        CodeCompileUnit ccu = cdv.codeCompileUnit;
78
 
                        
79
 
                        //C# parser seems to insist on putting imports in the "Global" namespace; fix it up
80
 
                        for (int i = 0; i < ccu.Namespaces.Count; i++) {
81
 
                                CodeNamespace global = ccu.Namespaces [i];
82
 
                                if ((global.Name == "Global") && (global.Types.Count == 0)) {
83
 
                                        global.Name = "";
84
 
                                        ccu.Namespaces.RemoveAt (i);
85
 
                                        ccu.Namespaces.Insert (0, global);
86
 
                                        
87
 
                                        //clear out repeat imports...
88
 
                                        for (int j = 1; j < ccu.Namespaces.Count; j++) {
89
 
                                                CodeNamespace cn = ccu.Namespaces [j];
90
 
                                                
91
 
                                                //why can't we remove imports? will have to collect ones to keep
92
 
                                                //then clear and refill
93
 
                                                CodeNamespaceImportCollection imps = new CodeNamespaceImportCollection ();
94
 
                                                
95
 
                                                for (int m = 0; m < cn.Imports.Count; m++) {
96
 
                                                        bool found = false;
97
 
                                                        
98
 
                                                        for (int n = 0; n < global.Imports.Count; n++)
99
 
                                                                if (global.Imports [n] == cn.Imports [m])
100
 
                                                                        found = true;
101
 
                                                
102
 
                                                        if (!found)
103
 
                                                                imps.Add (cn.Imports [m]);
104
 
                                                }
105
 
                                                
106
 
                                                cn.Imports.Clear ();
107
 
                                                
108
 
                                                foreach (CodeNamespaceImport imp in imps)
109
 
                                                        cn.Imports.Add (imp);
110
 
                                        }
111
 
                                        
112
 
                                        break;
113
 
                                }
114
 
                        }
115
 
                        return ccu;
 
80
                        var cs = codeStream.ReadToEnd ();
 
81
                        var tree = SyntaxTree.Parse (cs, "a.cs");
 
82
                        if (tree.Errors.Count > 0)
 
83
                                throw new ArgumentException ("Stream contained errors.");
 
84
 
 
85
                        var convertVisitor = new CodeDomConvertVisitor ();
 
86
                
 
87
                        return convertVisitor.Convert (Compilation.Value, tree, tree.ToTypeSystem ());
116
88
                }
117
89
                
118
90
                private class CodeParser : ICodeParser