← 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.Resolver/HelperMethods.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.Resolver/HelperMethods.cs
64
64
                        }
65
65
                }
66
66
                
67
 
                public static ICSharpCode.NRefactory.CSharp.CompilationUnit Parse (this ICSharpCode.NRefactory.CSharp.CSharpParser parser, TextEditorData data)
 
67
                public static ICSharpCode.NRefactory.CSharp.SyntaxTree Parse (this ICSharpCode.NRefactory.CSharp.CSharpParser parser, TextEditorData data)
68
68
                {
69
69
                        using (var stream = data.OpenStream ()) {
70
70
                                return parser.Parse (stream, data.Document.FileName);
71
71
                        }
72
72
                }
73
73
                
74
 
                public static AstNode ParseSnippet (this ICSharpCode.NRefactory.CSharp.CSharpParser parser, TextEditorData data)
75
 
                {
76
 
                        using (var stream = new  StreamReader (data.OpenStream ())) {
77
 
                                var result = parser.ParseExpression (stream);
78
 
                                if (!parser.HasErrors)
79
 
                                        return result;
80
 
                        }
81
 
                        parser.ErrorPrinter.Reset ();
82
 
                        using (var stream = new  StreamReader (data.OpenStream ())) {
83
 
                                var result = parser.ParseStatements (stream);
84
 
                                if (!parser.HasErrors)
85
 
                                        return result.FirstOrDefault ();
86
 
                        }
87
 
                        parser.ErrorPrinter.Reset ();
88
 
                        using (var stream = data.OpenStream ()) {
89
 
                                return parser.Parse (stream, data.Document.FileName);
90
 
                        }
91
 
                }
 
74
//              public static AstNode ParseSnippet (this ICSharpCode.NRefactory.CSharp.CSharpParser parser, TextEditorData data)
 
75
//              {
 
76
//                      using (var stream = new  StreamReader (data.OpenStream ())) {
 
77
//                              var result = parser.ParseExpression (stream);
 
78
//                              if (!parser.HasErrors)
 
79
//                                      return result;
 
80
//                      }
 
81
//                      parser.ErrorPrinter.Reset ();
 
82
//                      using (var stream = new  StreamReader (data.OpenStream ())) {
 
83
//                              var result = parser.ParseStatements (stream);
 
84
//                              if (!parser.HasErrors)
 
85
//                                      return result.FirstOrDefault ();
 
86
//                      }
 
87
//                      parser.ErrorPrinter.Reset ();
 
88
//                      using (var stream = data.OpenStream ()) {
 
89
//                              return parser.Parse (stream, data.Document.FileName);
 
90
//                      }
 
91
//              }
92
92
                
93
93
                public static MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy GetFormattingPolicy (this MonoDevelop.Ide.Gui.Document doc)
94
94
                {
121
121
                        if (parsedDocument == null)
122
122
                                return false;
123
123
 
124
 
                        var unit = parsedDocument.GetAst<CompilationUnit> ();
125
 
                        var parsedFile = parsedDocument.ParsedFile as CSharpParsedFile;
 
124
                        var unit = parsedDocument.GetAst<SyntaxTree> ();
 
125
                        var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
126
126
                        
127
127
                        if (unit == null || parsedFile == null)
128
128
                                return false;