public void UsingAliasDeclarationTest() { string program = "using TESTME=System;\n" + "using myAlias=My.Name.Space;\n" + "using StringCollection = System.Collections.Generic.List<string>;\n"; CSharpParser parser = new CSharpParser(); SyntaxTree syntaxTree = parser.Parse(program); Assert.IsFalse(parser.HasErrors); Assert.IsTrue(3 <= syntaxTree.Children.Count()); Assert.IsTrue(syntaxTree.Children.ElementAt(0) is UsingAliasDeclaration); UsingAliasDeclaration ud = (UsingAliasDeclaration)syntaxTree.Children.ElementAt(0); Assert.AreEqual("TESTME", ud.Alias); Assert.AreEqual("System", ud.Import.ToString()); Assert.IsTrue(syntaxTree.Children.Where (c => c.Role != Roles.NewLine).ElementAt(1) is UsingAliasDeclaration); ud = (UsingAliasDeclaration)syntaxTree.Children.Where (c => c.Role != Roles.NewLine).ElementAt(1); Assert.AreEqual("myAlias", ud.Alias); Assert.AreEqual("My.Name.Space", ud.Import.ToString()); Assert.IsTrue(syntaxTree.Children.Where (c => c.Role != Roles.NewLine).ElementAt(2) is UsingAliasDeclaration); ud = (UsingAliasDeclaration)syntaxTree.Children.Where (c => c.Role != Roles.NewLine).ElementAt(2); Assert.AreEqual("StringCollection", ud.Alias); Assert.AreEqual("System.Collections.Generic.List<string>", ud.Import.ToString()); }
public void UsingWithAliasing() { string program = "using global::System;\n" + "using myAlias=global::My.Name.Space;\n" + "using a::b.c;\n"; CSharpParser parser = new CSharpParser(); CompilationUnit cu = parser.Parse(new StringReader(program)); Assert.IsFalse(parser.HasErrors); Assert.AreEqual(3, cu.Children.Count()); Assert.IsTrue(cu.Children.ElementAt(0) is UsingDeclaration); Assert.IsFalse(cu.Children.ElementAt(0) is UsingAliasDeclaration); UsingDeclaration ud = (UsingDeclaration)cu.Children.ElementAt(0); Assert.AreEqual("global::System", ud.Namespace); Assert.IsTrue(cu.Children.ElementAt(1) is UsingAliasDeclaration); UsingAliasDeclaration uad = (UsingAliasDeclaration)cu.Children.ElementAt(1); Assert.AreEqual("myAlias", uad.Alias); Assert.AreEqual("global::My.Name.Space", uad.Import.ToString()); Assert.IsTrue(cu.Children.ElementAt(2) is UsingDeclaration); Assert.IsFalse(cu.Children.ElementAt(2) is UsingAliasDeclaration); ud = (UsingDeclaration)cu.Children.ElementAt(2); Assert.AreEqual("a::b.c", ud.Namespace); }
public void UsingAliasDeclarationTest() { string program = "using TESTME=System;\n" + "using myAlias=My.Name.Space;\n" + "using StringCollection = System.Collections.Generic.List<string>;\n"; CSharpParser parser = new CSharpParser(); CompilationUnit cu = parser.Parse(new StringReader(program)); Assert.IsFalse(parser.HasErrors); Assert.AreEqual(3, cu.Children.Count()); Assert.IsTrue(cu.Children.ElementAt(0) is UsingAliasDeclaration); UsingAliasDeclaration ud = (UsingAliasDeclaration)cu.Children.ElementAt(0); Assert.AreEqual("TESTME", ud.Alias); Assert.AreEqual("System", ud.Import.ToString()); Assert.IsTrue(cu.Children.ElementAt(1) is UsingAliasDeclaration); ud = (UsingAliasDeclaration)cu.Children.ElementAt(1); Assert.AreEqual("myAlias", ud.Alias); Assert.AreEqual("My.Name.Space", ud.Import.ToString()); Assert.IsTrue(cu.Children.ElementAt(2) is UsingAliasDeclaration); ud = (UsingAliasDeclaration)cu.Children.ElementAt(2); Assert.AreEqual("StringCollection", ud.Alias); Assert.AreEqual("System.Collections.Generic.List<string>", ud.Import.ToString()); }
public override IEntity ResolveCref(string cref) { if (cref.Length > 2 && cref[1] == ':') { // resolve ID string return base.ResolveCref(cref); } var documentationReference = new CSharpParser().ParseDocumentationReference(cref); var csharpContext = context as CSharpTypeResolveContext; CSharpResolver resolver; if (csharpContext != null) { resolver = new CSharpResolver(csharpContext); } else { resolver = new CSharpResolver(context.Compilation); } var astResolver = new CSharpAstResolver(resolver, documentationReference); var rr = astResolver.Resolve(documentationReference); MemberResolveResult mrr = rr as MemberResolveResult; if (mrr != null) return mrr.Member; TypeResolveResult trr = rr as TypeResolveResult; if (trr != null) return trr.Type.GetDefinition(); return null; }
public void GlobalReferenceExpressionTest() { CSharpParser parser = new CSharpParser(); parser.ParseTypeReference(new StringReader("global::System")); //Assert.IsTrue(tre.TypeReference.IsGlobal); //Assert.AreEqual("System", tre.TypeReference.Type); throw new NotImplementedException(); }
CSharpParsedFile Parse(string program) { CompilationUnit cu = new CSharpParser().Parse(new StringReader(program), "test.cs"); CSharpParsedFile parsedFile = cu.ToTypeSystem(); project = project.UpdateProjectContent(null, parsedFile); compilation = project.CreateCompilation(); return parsedFile; }
public void WrongUsingTest() { string program = "using\n"; CSharpParser parser = new CSharpParser(); CompilationUnit cu = parser.Parse(new StringReader(program)); Assert.AreEqual(0, cu.Children.Count()); Assert.IsTrue(parser.HasErrors); }
public void WrongUsingTest() { string program = "using\n"; CSharpParser parser = new CSharpParser(); SyntaxTree syntaxTree = parser.Parse (program); Assert.AreEqual(0, syntaxTree.Children.Count()); Assert.IsTrue(parser.HasErrors); }
public CodeRoot GetCodeRoot(string path) { if (File.Exists(path) == false) return null; CSharpParser formatter = new CSharpParser(); formatter.ParseCode(File.ReadAllText(path)); return (CodeRoot)formatter.CreatedCodeRoot; }
public void IfIsIdentifiedAsKeyword() { var expression = "if (System.Console.ReadLine() == \"a\") { System.Console.WriteLine(\"Oh!\"); }"; var result = new CSharpParser().Parse(expression); var ifChunk = result.TextChunks.First(ch => ch.TextValue == "if"); ExpressionHelper.Check(expression, result); Assert.AreEqual(Common.CodeType.Keyword, ifChunk.CodeType); }
public void SingleLineCommentsAreDiscovered() { var expression = "var a = 1 + 3; // comment"; var result = new CSharpParser().Parse(expression); var aChunk = result.TextChunks.First(ch => ch.TextValue == "// comment"); ExpressionHelper.Check(expression, result); Assert.AreEqual(CodeType.Comment, aChunk.CodeType); }
public void InitializationTypeType() { var expression = "var a = new System.Int32();"; var result = new CSharpParser().Parse(expression); var intChunk = result.TextChunks.First(ch => ch.TextValue == "Int32"); ExpressionHelper.Check(expression, result); Assert.AreEqual(CodeType.Type, intChunk.CodeType); Assert.AreEqual("struct System.Int32", intChunk.TooltipValue); }
public void DeclarationGenericTypeType() { var expression = "System.Tuple<int, int> a = System.Tuple.Create(1, 1);"; var result = new CSharpParser().Parse(expression); var intChunk = result.TextChunks.First(ch => ch.TextValue == "Tuple"); ExpressionHelper.Check(expression, result); Assert.AreEqual(CodeType.Type, intChunk.CodeType); Assert.AreEqual("class System.Tuple", intChunk.TooltipValue); }
public void DeclarationPredefinedTypeType() { var expression = "int a = 1 + 3;"; var result = new CSharpParser().Parse(expression); var intChunk = result.TextChunks.First(ch => ch.TextValue == "int"); ExpressionHelper.Check(expression, result); Assert.AreEqual(CodeType.Keyword, intChunk.CodeType); Assert.AreEqual("struct System.Int32", intChunk.TooltipValue); }
public void VarType() { var expression = "var a = 1 + 3;"; var result = new CSharpParser().Parse(expression); var varChunk = result.TextChunks.First(ch => ch.TextValue == "var"); ExpressionHelper.Check(expression, result); Assert.AreEqual(CodeType.Keyword, varChunk.CodeType); Assert.AreEqual("struct System.Int32", varChunk.TooltipValue); }
public void SimpleMethodIsMarkedAsMethod() { var expression = "string.Join(\",\", new[]{\"a\", \"b\"})"; var result = new CSharpParser().Parse(expression); var intChunk = result.TextChunks.First(ch => ch.TextValue == "Join"); ExpressionHelper.Check(expression, result); Assert.AreEqual(Common.CodeType.Method, intChunk.CodeType); Assert.AreEqual("string string.Join(string separator, params string[] value)", intChunk.TooltipValue); }
public void ItemPropertyOfTupleIsDiscovered() { var expression = "var t = System.Tuple.Create(1, 2, 3); System.Console.WriteLine(t.Item2);"; var result = new CSharpParser().Parse(expression); var propertyChunk = result.TextChunks.First(ch => ch.TextValue == "Item2"); ExpressionHelper.Check(expression, result); Assert.AreEqual(Common.CodeType.Property, propertyChunk.CodeType); Assert.AreEqual("System.Tuple<int, int, int>.Item2", propertyChunk.TooltipValue); }
public void OverloadResolutionWorks() { var expression = "string.Join(\",\", new[]{2, 5})"; var result = new CSharpParser().Parse(expression); var intChunk = result.TextChunks.First(ch => ch.TextValue == "Join"); ExpressionHelper.Check(expression, result); Assert.AreEqual(Common.CodeType.Method, intChunk.CodeType); Assert.AreEqual("string string.Join<int>(string separator, System.Collections.Generic.IEnumerable<int> values)", intChunk.TooltipValue); }
public void VariableMentionType() { var expression = "var a = 1 + 3; var b = a;"; var result = new CSharpParser().Parse(expression); var aMention = result.TextChunks.Where(ch => ch.TextValue == "a").Skip(1).First(); ExpressionHelper.Check(expression, result); Assert.AreEqual(CodeType.Variable, aMention.CodeType); Assert.AreEqual("struct System.Int32", aMention.TooltipValue); }
public void NamespaceInUsingIsRecognized() { var expression = "using System.Collections.Generic;"; var result = new CSharpParser().Parse(expression); var namespaceChunk = result.TextChunks.First(ch => ch.TextValue == "Generic"); ExpressionHelper.Check(expression, result); Assert.AreEqual(Common.CodeType.Namespace, namespaceChunk.CodeType); Assert.AreEqual("System.Collections.Generic", namespaceChunk.TooltipValue); }
public void GlobalReferenceExpressionTest() { CSharpParser parser = new CSharpParser(); AstType type = parser.ParseTypeReference(new StringReader("global::System")); Assert.IsNotNull( new MemberType { Target = new SimpleType("global"), IsDoubleColon = true, MemberName = "System" }.Match(type) ); }
public void ClassIsIdentifiedAsKeyword() { var expression = "public class Implementation { }"; var result = new CSharpParser().Parse(expression); var publicChunk = result.TextChunks.First(ch => ch.TextValue == "public"); var classChunk = result.TextChunks.First(ch => ch.TextValue == "class"); ExpressionHelper.Check(expression, result); Assert.AreEqual(Common.CodeType.Keyword, classChunk.CodeType); Assert.AreEqual(Common.CodeType.Keyword, publicChunk.CodeType); }
public void ParseAndCheckPositions() { CSharpParser parser = new CSharpParser(); foreach (string fileName in fileNames) { var currentDocument = new ReadOnlyDocument(File.ReadAllText(fileName)); SyntaxTree syntaxTree = parser.Parse(currentDocument, fileName); if (parser.HasErrors) continue; ConsistencyChecker.CheckPositionConsistency(syntaxTree, fileName, currentDocument); ConsistencyChecker.CheckMissingTokens(syntaxTree, fileName, currentDocument); } }
internal static IProjectContent ParseTestCase() { const string fileName = "TypeSystemTests.TestCase.cs"; CSharpParser parser = new CSharpParser(); SyntaxTree syntaxTree; using (Stream s = typeof(TypeSystemTests).Assembly.GetManifestResourceStream(typeof(TypeSystemTests), fileName)) { syntaxTree = parser.Parse(s, fileName); } return CreateContent(syntaxTree.ToTypeSystem()); }
public void ParseAndCheckPositions() { CSharpParser parser = new CSharpParser(); foreach (string fileName in fileNames) { this.currentDocument = new ReadOnlyDocument(File.ReadAllText(fileName)); CompilationUnit cu = parser.Parse(currentDocument.CreateReader(), fileName); if (parser.HasErrors) continue; this.currentFileName = fileName; CheckPositionConsistency(cu); CheckMissingTokens(cu); } }
public void AssemblyAndModuleAttributesDoNotAppearOnTypes() { var parser = new CSharpParser(); var cu = parser.Parse("[assembly: My1][module: My2][My3]class C {} public class My1Attribute : System.Attribute {} public class My2Attribute : System.Attribute {} public class My3Attribute : System.Attribute {}", "File.cs"); var ts = cu.ToTypeSystem(); var compilation = new CSharpProjectContent() .UpdateProjectContent(null, ts) .AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib }) .CreateCompilation(); var type = ReflectionHelper.ParseReflectionName("C").Resolve(compilation).GetDefinition(); Assert.That(type.Attributes.Select(a => a.AttributeType.FullName).ToList(), Is.EqualTo(new[] { "My3Attribute" })); }
public void SetUp() { pc = new SimpleProjectContent(); var cu = new CSharpParser().Parse(new StringReader(program)); parsedFile = new TypeSystemConvertVisitor(pc, "program.cs").Convert(cu); pc.UpdateProjectContent(null, parsedFile); ctx = new CompositeTypeResolveContext(new[] { pc, CecilLoaderTests.Mscorlib }); baseClass = pc.GetTypeDefinition(string.Empty, "Base", 1, StringComparer.Ordinal); nestedClass = baseClass.NestedTypes.Single(); derivedClass = pc.GetTypeDefinition(string.Empty, "Derived", 2, StringComparer.Ordinal); systemClass = pc.GetTypeDefinition("NS", "System", 0, StringComparer.Ordinal); }
public void GenerateTypeSystem() { SimpleProjectContent pc = new SimpleProjectContent(); CSharpParser parser = new CSharpParser(); parser.GenerateTypeSystemMode = true; foreach (string fileName in fileNames) { CompilationUnit cu; using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) { cu = parser.Parse(fs); } TypeSystemConvertVisitor cv = new TypeSystemConvertVisitor(pc, fileName); pc.UpdateProjectContent(null, cv.Convert(cu)); } }
internal static IProjectContent ParseTestCase() { const string fileName = "TypeSystemTests.TestCase.cs"; CSharpParser parser = new CSharpParser(); CompilationUnit cu; using (Stream s = typeof(TypeSystemTests).Assembly.GetManifestResourceStream(typeof(TypeSystemTests), fileName)) { cu = parser.Parse(s, fileName); } var parsedFile = cu.ToTypeSystem(); return new CSharpProjectContent() .UpdateProjectContent(null, parsedFile) .AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib }) .SetAssemblyName(typeof(TypeSystemTests).Assembly.GetName().Name); }
public void TestV2 () { var input = @"class Foo { void Bar (object o) { Foo foo = (Foo)o; } }"; TestRefactoringContext context; CSharpParser parser = new CSharpParser(); parser.CompilerSettings.LanguageVersion = new Version(2, 0, 0); var issues = GetIssues (new SuggestUseVarKeywordEvidentIssue (), input, out context, false, parser); Assert.AreEqual (0, issues.Count); }
/// <summary> /// Tries to parses specified data string into syntactic item. /// </summary> protected override bool Parse(SyntacticItem item, string data) { return(CSharpParser.TryParse(item, data)); }
public static TestRefactoringContext Create(string content, bool expectErrors = false, CSharpParser parser = null) { return(Create(new List <string>() { content }, 0, expectErrors, parser)); }
// // Processes "see" or "seealso" elements from cref attribute. // void HandleXrefCommon(MemberCore mc, DeclSpace ds, XmlElement xref) { string cref = xref.GetAttribute("cref"); // when, XmlReader, "if (cref == null)" if (!xref.HasAttribute("cref")) { return; } // Nothing to be resolved the reference is marked explicitly if (cref.Length > 2 && cref [1] == ':') { return; } // Additional symbols for < and > are allowed for easier XML typing cref = cref.Replace('{', '<').Replace('}', '>'); var encoding = module.Compiler.Settings.Encoding; var s = new MemoryStream(encoding.GetBytes(cref)); SeekableStreamReader seekable = new SeekableStreamReader(s, encoding); var source_file = new CompilationSourceFile("{documentation}", "", 1); var doc_module = new ModuleContainer(module.Compiler); doc_module.DocumentationBuilder = this; source_file.NamespaceContainer = new NamespaceContainer(null, doc_module, null, source_file); Report parse_report = new Report(new NullReportPrinter()); var parser = new CSharpParser(seekable, source_file, parse_report); ParsedParameters = null; ParsedName = null; ParsedBuiltinType = null; ParsedOperator = null; parser.Lexer.putback_char = Tokenizer.DocumentationXref; parser.Lexer.parsing_generic_declaration_doc = true; parser.parse(); if (parse_report.Errors > 0) { Report.Warning(1584, 1, mc.Location, "XML comment on `{0}' has syntactically incorrect cref attribute `{1}'", mc.GetSignatureForError(), cref); xref.SetAttribute("cref", "!:" + cref); return; } MemberSpec member; string prefix = null; FullNamedExpression fne = null; // // Try built-in type first because we are using ParsedName as identifier of // member names on built-in types // if (ParsedBuiltinType != null && (ParsedParameters == null || ParsedName != null)) { member = ParsedBuiltinType.Type; } else { member = null; } if (ParsedName != null || ParsedOperator.HasValue) { TypeSpec type = null; string member_name = null; if (member == null) { if (ParsedOperator.HasValue) { type = mc.CurrentType; } else if (ParsedName.Left != null) { fne = ResolveMemberName(mc, ParsedName.Left); if (fne != null) { var ns = fne as Namespace; if (ns != null) { fne = ns.Lookup(mc, ParsedName.Name, ParsedName.Arity, Location.Null); if (fne != null) { member = fne.Type; } } else { type = fne.Type; } } } else { fne = ResolveMemberName(mc, ParsedName); if (fne == null) { type = mc.CurrentType; } else if (ParsedParameters == null) { member = fne.Type; } else if (fne.Type.MemberDefinition == mc.CurrentType.MemberDefinition) { member_name = Constructor.ConstructorName; type = fne.Type; } } } else { type = (TypeSpec)member; member = null; } if (ParsedParameters != null) { foreach (var pp in ParsedParameters) { pp.Resolve(mc); } } if (type != null) { if (member_name == null) { member_name = ParsedOperator.HasValue ? Operator.GetMetadataName(ParsedOperator.Value) : ParsedName.Name; } int parsed_param_count; if (ParsedOperator == Operator.OpType.Explicit || ParsedOperator == Operator.OpType.Implicit) { parsed_param_count = ParsedParameters.Count - 1; } else if (ParsedParameters != null) { parsed_param_count = ParsedParameters.Count; } else { parsed_param_count = 0; } int parameters_match = -1; do { var members = MemberCache.FindMembers(type, member_name, true); if (members != null) { foreach (var m in members) { if (ParsedName != null && m.Arity != ParsedName.Arity) { continue; } if (ParsedParameters != null) { IParametersMember pm = m as IParametersMember; if (pm == null) { continue; } if (m.Kind == MemberKind.Operator && !ParsedOperator.HasValue) { continue; } int i; for (i = 0; i < parsed_param_count; ++i) { var pparam = ParsedParameters[i]; if (i >= pm.Parameters.Count || pparam == null || pparam.TypeSpec != pm.Parameters.Types[i] || (pparam.Modifier & Parameter.Modifier.SignatureMask) != (pm.Parameters.FixedParameters[i].ModFlags & Parameter.Modifier.SignatureMask)) { if (i > parameters_match) { parameters_match = i; } i = -1; break; } } if (i < 0) { continue; } if (ParsedOperator == Operator.OpType.Explicit || ParsedOperator == Operator.OpType.Implicit) { if (pm.MemberType != ParsedParameters[parsed_param_count].TypeSpec) { parameters_match = parsed_param_count + 1; continue; } } else { if (parsed_param_count != pm.Parameters.Count) { continue; } } } if (member != null) { Report.Warning(419, 3, mc.Location, "Ambiguous reference in cref attribute `{0}'. Assuming `{1}' but other overloads including `{2}' have also matched", cref, member.GetSignatureForError(), m.GetSignatureForError()); break; } member = m; } } // Continue with parent type for nested types if (member == null) { type = type.DeclaringType; } else { type = null; } } while (type != null); if (member == null && parameters_match >= 0) { for (int i = parameters_match; i < parsed_param_count; ++i) { Report.Warning(1580, 1, mc.Location, "Invalid type for parameter `{0}' in XML comment cref attribute `{1}'", (i + 1).ToString(), cref); } if (parameters_match == parsed_param_count + 1) { Report.Warning(1581, 1, mc.Location, "Invalid return type in XML comment cref attribute `{0}'", cref); } } } } if (member == null) { Report.Warning(1574, 1, mc.Location, "XML comment on `{0}' has cref attribute `{1}' that could not be resolved", mc.GetSignatureForError(), cref); cref = "!:" + cref; } else if (member == InternalType.Namespace) { cref = "N:" + fne.GetSignatureForError(); } else { prefix = GetMemberDocHead(member); cref = prefix + member.GetSignatureForDocumentation(); } xref.SetAttribute("cref", cref); }
public void TestMaxInstances2() { var test = @" using System; using Microsoft.PSharp; namespace SystematicTesting { class E1 : Event { public E1() : base(1, -1) { } } class E2 : Event { public E2() : base(1, -1) { } } class E3 : Event { public E3() : base(-1, -1) { } } class E4 : Event { } class Unit : Event { public Unit() : base(1, -1) { } } class RealMachine : Machine { MachineId GhostMachine; [Start] [OnEntry(nameof(EntryInit))] [OnEventPushState(typeof(Unit), typeof(S1))] [OnEventGotoState(typeof(E4), typeof(S2))] [OnEventDoAction(typeof(E2), nameof(Action1))] class Init : MachineState { } void EntryInit() { GhostMachine = this.CreateMachine(typeof(GhostMachine), this.Id); this.Raise(new Unit()); } [OnEntry(nameof(EntryS1))] class S1 : MachineState { } void EntryS1() { this.Send(GhostMachine, new E1()); } [OnEntry(nameof(EntryS2))] [OnEventGotoState(typeof(Unit), typeof(S3))] class S2 : MachineState { } void EntryS2() { this.Raise(new Unit()); } [OnEventGotoState(typeof(E4), typeof(S3))] class S3 : MachineState { } void Action1() { this.Assert((int)this.Payload == 100); this.Send(GhostMachine, new E3()); this.Send(GhostMachine, new E3()); } } class GhostMachine : Machine { MachineId RealMachine; [Start] [OnEntry(nameof(EntryInit))] [OnEventGotoState(typeof(Unit), typeof(GhostInit))] class Init : MachineState { } void EntryInit() { RealMachine = this.Payload as MachineId; this.Raise(new Unit()); } [OnEventGotoState(typeof(E1), typeof(S1))] class GhostInit : MachineState { } [OnEntry(nameof(EntryS1))] [OnEventGotoState(typeof(E3), typeof(S2))] [IgnoreEvents(typeof(E1))] class S1 : MachineState { } void EntryS1() { this.Send(RealMachine, new E2(), 100); } [OnEntry(nameof(EntryS2))] [OnEventGotoState(typeof(E3), typeof(GhostInit))] class S2 : MachineState { } void EntryS2() { this.Send(RealMachine, new E4()); this.Send(RealMachine, new E4()); this.Send(RealMachine, new E4()); } } public static class TestProgram { public static void Main(string[] args) { TestProgram.Execute(); Console.ReadLine(); } [Test] public static void Execute() { PSharpRuntime.CreateMachine(typeof(RealMachine)); } } }"; var parser = new CSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), true); var program = parser.Parse(); program.Rewrite(); var sctConfig = new DynamicAnalysisConfiguration(); sctConfig.SuppressTrace = true; sctConfig.Verbose = 2; sctConfig.SchedulingStrategy = SchedulingStrategy.DFS; var assembly = base.GetAssembly(program.GetSyntaxTree()); var context = AnalysisContext.Create(sctConfig, assembly); var sctEngine = SCTEngine.Create(context).Run(); Assert.AreEqual(0, sctEngine.NumOfFoundBugs); }
public void TestSimpleAsyncAwaitFail() { var test = @" using System; using System.Collections.Generic; using System.Threading.Tasks; using Microsoft.PSharp; namespace SystematicTesting { class Unit : Event { } internal class TaskCreator : Machine { int Value; [Start] [OnEntry(nameof(InitOnEntry))] [OnEventGotoState(typeof(Unit), typeof(Active))] class Init : MachineState { } void InitOnEntry() { this.Value = 0; this.Raise(new Unit()); } [OnEntry(nameof(ActiveOnEntry))] class Active : MachineState { } void ActiveOnEntry() { Process(); this.Assert(this.Value < 3, ""Value is '{0}' (expected less than '3')."", this.Value); } async void Process() { Task t = Increment(); this.Value++; await t; this.Value++; } Task Increment() { Task t = new Task(() => { this.Value++; }); t.Start(); return t; } } public static class TestProgram { public static void Main(string[] args) { TestProgram.Execute(); Console.ReadLine(); } [Test] public static void Execute() { PSharpRuntime.CreateMachine(typeof(TaskCreator)); } } }"; var parser = new CSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), true); var program = parser.Parse(); program.Rewrite(); var sctConfig = new DynamicAnalysisConfiguration(); sctConfig.SuppressTrace = true; sctConfig.Verbose = 2; sctConfig.SchedulingIterations = 2; sctConfig.SchedulingStrategy = SchedulingStrategy.DFS; sctConfig.ScheduleIntraMachineConcurrency = true; var assembly = base.GetAssembly(program.GetSyntaxTree()); var context = AnalysisContext.Create(sctConfig, assembly); var sctEngine = SCTEngine.Create(context).Run(); var bugReport = "Value is '3' (expected less than '3')."; Assert.AreEqual(bugReport, sctEngine.BugReport); }
public static VariableInitializer GetVariableDeclarationForLinqQuery(string query, bool requiresSelectNewAnonymousType) { try { var parser = new CSharpParser(); var block = parser.ParseStatements(ToQueryStatement(query)).ToList(); if (block.Count == 0 || parser.HasErrors) { var errs = string.Join(Environment.NewLine, parser.Errors.Select(x => x.Region + ": " + x.ErrorType + " - " + x.Message)); throw new InvalidOperationException("Could not understand query: \r\n" + errs); } var declaration = block[0] as VariableDeclarationStatement; if (declaration == null) { throw new InvalidOperationException("Only local variable declaration are allowed"); } if (declaration.Variables.Count != 1) { throw new InvalidOperationException("Only one variable declaration is allowed"); } var variable = declaration.Variables.First(); if (variable.Initializer == null) { throw new InvalidOperationException("Variable declaration must have an initializer"); } var queryExpression = (variable.Initializer as QueryExpression); if (queryExpression == null) { throw new InvalidOperationException("Variable initializer must be a query expression"); } var selectClause = queryExpression.Clauses.OfType <QuerySelectClause>().FirstOrDefault(); if (selectClause == null) { throw new InvalidOperationException("Variable initializer must be a select query expression"); } var createExpression = GetAnonymousCreateExpression(selectClause.Expression) as AnonymousTypeCreateExpression; if ((createExpression == null) && requiresSelectNewAnonymousType) { throw new InvalidOperationException( "Variable initializer must be a select query expression returning an anonymous object"); } variable.AcceptVisitor(new TransformNullCoalescingOperatorTransformer(), null); variable.AcceptVisitor(new DynamicExtensionMethodsTranslator(), null); variable.AcceptVisitor(new TransformDynamicLambdaExpressions(), null); variable.AcceptVisitor(new TransformDynamicInvocationExpressions(), null); variable.AcceptVisitor(new TransformObsoleteMethods(), null); return(variable); } catch (Exception e) { throw new InvalidOperationException("Could not understand query: " + e.Message, e); } }
public void TestExitAtExplicitPop() { var test = @" using System; using Microsoft.PSharp; namespace SystematicTesting { class E : Event { } class Real1 : Machine { bool test = false; [Start] [OnEntry(nameof(EntryInit))] [OnExit(nameof(ExitInit))] [OnEventPushState(typeof(E), typeof(Call))] class Init : MachineState { } void EntryInit() { this.Raise(new E()); } void ExitInit() { } [OnEntry(nameof(EntryCall))] [OnExit(nameof(ExitCall))] class Call : MachineState { } void EntryCall() { this.Pop(); } void ExitCall() { this.Assert(false); } } public static class TestProgram { public static void Main(string[] args) { TestProgram.Execute(); Console.ReadLine(); } [Test] public static void Execute() { PSharpRuntime.CreateMachine(typeof(Real1)); } } }"; var parser = new CSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), true); var program = parser.Parse(); program.Rewrite(); var sctConfig = new DynamicAnalysisConfiguration(); sctConfig.SuppressTrace = true; sctConfig.Verbose = 2; var assembly = base.GetAssembly(program.GetSyntaxTree()); var context = AnalysisContext.Create(sctConfig, assembly); var sctEngine = SCTEngine.Create(context).Run(); Assert.AreEqual(1, sctEngine.NumOfFoundBugs); }
public static TestRefactoringContext Create(List <string> contents, int mainIndex, bool expectErrors = false, CSharpParser parser = null) { List <int> indexes = new List <int>(); List <int> selectionStarts = new List <int>(); List <int> selectionEnds = new List <int>(); List <IDocument> documents = new List <IDocument>(); List <CSharpUnresolvedFile> unresolvedFiles = new List <CSharpUnresolvedFile>(); List <SyntaxTree> units = new List <SyntaxTree>(); for (int i = 0; i < contents.Count; i++) { string content = contents[i]; int idx = content.IndexOf("$"); if (idx >= 0) { content = content.Substring(0, idx) + content.Substring(idx + 1); } int idx1 = content.IndexOf("<-"); int idx2 = content.IndexOf("->"); int selectionStart = 0; int selectionEnd = 0; if (0 <= idx1 && idx1 < idx2) { content = content.Substring(0, idx2) + content.Substring(idx2 + 2); content = content.Substring(0, idx1) + content.Substring(idx1 + 2); selectionStart = idx1; selectionEnd = idx2 - 2; idx = selectionEnd; } indexes.Add(idx); selectionStarts.Add(selectionStart); selectionEnds.Add(selectionEnd); var doc = new StringBuilderDocument(content); if (parser == null) { parser = new CSharpParser(); } var unit = parser.Parse(content, "program_" + i + ".cs"); if (!expectErrors) { if (parser.HasErrors) { Console.WriteLine(content); Console.WriteLine("----"); } foreach (var error in parser.ErrorsAndWarnings) { Console.WriteLine(error.Message); } Assert.IsFalse(parser.HasErrors, "The file " + i + " contains unexpected parsing errors."); } else { Assert.IsTrue(parser.HasErrors, "Expected parsing errors, but the file " + i + "doesn't contain any."); } unit.Freeze(); CSharpUnresolvedFile unresolvedFile = unit.ToTypeSystem(); units.Add(unit); documents.Add(doc); unresolvedFiles.Add(unresolvedFile); } IProjectContent pc = new CSharpProjectContent(); pc = pc.AddOrUpdateFiles(unresolvedFiles); pc = pc.AddAssemblyReferences(new[] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore }); var compilation = pc.CreateCompilation(); List <TestRefactoringContext> contexts = new List <TestRefactoringContext>(); for (int documentIndex = 0; documentIndex < documents.Count; ++documentIndex) { var doc = documents [documentIndex]; var resolver = new CSharpAstResolver(compilation, units[documentIndex], unresolvedFiles[documentIndex]); TextLocation location = TextLocation.Empty; if (indexes[documentIndex] >= 0) { location = doc.GetLocation(indexes[documentIndex]); } var context = new TestRefactoringContext(doc, location, resolver) { selectionStart = selectionStarts[documentIndex], selectionEnd = selectionEnds[documentIndex], projectContexts = contexts, version = parser.CompilerSettings.LanguageVersion, defaultNamespace = "Test" }; contexts.Add(context); } return(contexts [mainIndex]); }
// ======================================================================== // Properties #region === Properties #endregion #endregion // ======================================================================== // Methods #region === Methods /// <summary> /// The main entry point of this class. Imports the C# file which is given /// as the parameter. /// </summary> /// <param name="fileName">The file path of C# source code to import.</param> /// <returns><c>True</c>, if the import was successful.</returns> public bool ImportSourceCode(string fileName) { if (string.IsNullOrEmpty(fileName)) { MessageBox.Show(Strings.Error_NoCSharpFile, Strings.Error_MessageBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error); return(false); } try { diagram.Name = Path.GetFileName(fileName); diagram.RedrawSuspended = true; CSharpParser parser = new CSharpParser(); // Open the C# source file to read using (StreamReader sr = new StreamReader(fileName)) { // Parse the C# file SyntaxTree syntaxTree = parser.Parse(sr, fileName); if (parser.HasErrors == false) { foreach (TypeDeclaration tp in syntaxTree.Descendants.OfType <TypeDeclaration>()) { switch (tp.ClassType) { case ICSharpCode.NRefactory.CSharp.ClassType.Class: AddClass(tp); continue; case ICSharpCode.NRefactory.CSharp.ClassType.Struct: AddStrct(tp); continue; case ICSharpCode.NRefactory.CSharp.ClassType.Interface: AddInterface(tp); continue; case ICSharpCode.NRefactory.CSharp.ClassType.Enum: AddEnum(tp); continue; default: continue; } } foreach (DelegateDeclaration dd in syntaxTree.Descendants.OfType <DelegateDeclaration>()) { AddDelegate(dd); } Common.ArrangeTypes(diagram); /* * RelationshipCreator relationshipCreator = new RelationshipCreator(); * * NRRelationships nrRelationships = relationshipCreator.CreateRelationships(nrAssembly, settings.CreateNestings, * settings.CreateGeneralizations, * settings.CreateRealizations, * settings.CreateAssociations); * AddRelationships(); */ } else { MessageBox.Show(String.Format(Strings.Error_CSharpParsing, fileName, parser.Errors.Select(err => err.Message)), Strings.Error_MessageBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error); return(false); } } } catch (Exception ex) { MessageBox.Show(String.Format(Strings.Error_GeneralException, ex), Strings.Error_MessageBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error); return(false); } finally { diagram.RedrawSuspended = false; } return(true); }
public static void Main(string[] args) { try { string[] files = Directory.GetFiles(".", "*.cs"); foreach (string file in files) { Console.WriteLine(file + "---------------------------------------"); //Read the file string text = File.ReadAllText(file); //Create the lexer CSharpLexer lexer = new CSharpLexer(new AntlrInputStream(text)); var tokens = lexer.GetAllTokens(); List <IToken> codeTokens = new List <IToken>(); List <IToken> commentTokens = new List <IToken>(); var directiveTokens = new List <IToken>(); var directiveTokenSource = new ListTokenSource(directiveTokens); var directiveTokenStream = new CommonTokenStream(directiveTokenSource, CSharpLexer.DIRECTIVE); CSharpPreprocessorParser preprocessorParser = new CSharpPreprocessorParser(directiveTokenStream); int index = 0; bool compiliedTokens = true; while (index < tokens.Count) { var token = tokens[index]; if (token.Type == CSharpLexer.SHARP) { directiveTokens.Clear(); int directiveTokenIndex = index + 1; // Collect all preprocessor directive tokens. while (directiveTokenIndex < tokens.Count && tokens[directiveTokenIndex].Type != CSharpLexer.Eof && tokens[directiveTokenIndex].Type != CSharpLexer.DIRECTIVE_NEW_LINE && tokens[directiveTokenIndex].Type != CSharpLexer.SHARP) { if (tokens[directiveTokenIndex].Channel == CSharpLexer.COMMENTS_CHANNEL) { commentTokens.Add(tokens[directiveTokenIndex]); } else if (tokens[directiveTokenIndex].Channel != Lexer.Hidden) { //Console.WriteLine(allTokens[directiveTokenIndex] + " HOLA"); directiveTokens.Add(tokens[directiveTokenIndex]); } directiveTokenIndex++; } directiveTokenSource = new ListTokenSource(directiveTokens); directiveTokenStream = new CommonTokenStream(directiveTokenSource, CSharpLexer.DIRECTIVE); preprocessorParser.TokenStream = directiveTokenStream; //preprocessorParser.SetInputStream(directiveTokenStream); preprocessorParser.Reset(); // Parse condition in preprocessor directive (based on CSharpPreprocessorParser.g4 grammar). CSharpPreprocessorParser.Preprocessor_directiveContext directive = preprocessorParser.preprocessor_directive(); // if true than next code is valid and not ignored. compiliedTokens = directive.value; String directiveStr = tokens[index + 1].Text.Trim(); if ("line".Equals(directiveStr) || "error".Equals(directiveStr) || "warning".Equals(directiveStr) || "define".Equals(directiveStr) || "endregion".Equals(directiveStr) || "endif".Equals(directiveStr) || "pragma".Equals(directiveStr)) { //Console.WriteLine(directiveStr); compiliedTokens = true; } String conditionalSymbol = null; if ("define".Equals(tokens[index + 1].Text)) { // add to the conditional symbols conditionalSymbol = tokens[index + 2].Text; preprocessorParser.ConditionalSymbols.Add(conditionalSymbol); } if ("undef".Equals(tokens[index + 1].Text)) { conditionalSymbol = tokens[index + 2].Text; preprocessorParser.ConditionalSymbols.Remove(conditionalSymbol); } //This code deletes the directive tokens from the input so that they don't interfere with the parsing process // In all of the cases, we have to remove at least two positions of the tokens array tokens.RemoveAt(directiveTokenIndex - 1); tokens.RemoveAt(directiveTokenIndex - 2); if ("pragma".Equals(directiveStr) || "warning".Equals(directiveStr) || "region".Equals(directiveStr) || "error".Equals(directiveStr)) { // Remove three positions before tokens.RemoveAt(directiveTokenIndex - 3); directiveTokenIndex--; } else if ("define".Equals(directiveStr) || "undef".Equals(directiveStr) || "if".Equals(directiveStr) || "elif".Equals(directiveStr) || "line".Equals(directiveStr)) { // Remove four positions before tokens.RemoveAt(directiveTokenIndex - 3); tokens.RemoveAt(directiveTokenIndex - 4); directiveTokenIndex -= 2; } directiveTokenIndex -= 2; index = directiveTokenIndex - 1; } else if (token.Channel == CSharpLexer.COMMENTS_CHANNEL) { commentTokens.Add(token); // Colect comment tokens (if required). } else if (token.Channel != Lexer.Hidden && token.Type != CSharpLexer.DIRECTIVE_NEW_LINE && compiliedTokens) { codeTokens.Add(token); // Collect code tokens. } index++; } // At second stage tokens parsed in usual way. var codeTokenSource = new ListTokenSource(tokens); var codeTokenStream = new CommonTokenStream(codeTokenSource); CSharpParser parser = new CSharpParser(codeTokenStream); ////Create the token stream //CommonTokenStream tokens = new CommonTokenStream(lexer); //CSharpParser parser = new CSharpParser(tokens); IParseTree tree = parser.compilation_unit(); ////Walk the tree ParseTreeWalker walker = new ParseTreeWalker(); walker.Walk(new ProgressPrinter(), tree); } } catch (Exception e) { Console.WriteLine("Error (Program.cs): " + e); } }
public void TestPushItself() { var test = @" using System; using Microsoft.PSharp; namespace SystematicTesting { class E1 : Event { public E1() : base(1, -1) { } } class E2 : Event { public E2() : base(1, -1) { } } class Real1 : Machine { [Start] [OnEntry(nameof(EntryInit))] [OnExit(nameof(ExitInit))] [OnEventGotoState(typeof(E1), typeof(Init))] [OnEventPushState(typeof(E2), typeof(Init))] class Init : MachineState { } void EntryInit() { this.Send(this.Id, new E1()); } void ExitInit() { this.Send(this.Id, new E2()); } } public static class TestProgram { public static void Main(string[] args) { TestProgram.Execute(); Console.ReadLine(); } [Test] public static void Execute() { PSharpRuntime.CreateMachine(typeof(Real1)); } } }"; var parser = new CSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), true); var program = parser.Parse(); program.Rewrite(); var sctConfig = new DynamicAnalysisConfiguration(); sctConfig.SuppressTrace = true; sctConfig.Verbose = 2; var assembly = base.GetAssembly(program.GetSyntaxTree()); var context = AnalysisContext.Create(sctConfig, assembly); var sctEngine = SCTEngine.Create(context).Run(); Assert.AreEqual(1, sctEngine.NumOfFoundBugs); }
public void TestNewMonitor2() { var test = @" using System; using Microsoft.PSharp; namespace SystematicTesting { class E2 : Event { public E2() : base(1, -1) { } } class Real1 : Machine { bool test = false; [Start] [OnEntry(nameof(EntryInit))] class Init : MachineState { } void EntryInit() { this.CreateMonitor(typeof(M), true); this.Monitor<M>(null, test); } } class M : Monitor { [Start] [OnEntry(nameof(EntryX))] class X : MonitorState { } void EntryX() { //this.Assert((bool)this.Payload == true); // passes } } public static class TestProgram { public static void Main(string[] args) { TestProgram.Execute(); Console.ReadLine(); } [Test] public static void Execute() { PSharpRuntime.CreateMachine(typeof(Real1)); } } }"; var parser = new CSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), true); var program = parser.Parse(); program.Rewrite(); Configuration.SuppressTrace = true; Configuration.Verbose = 2; Configuration.SchedulingStrategy = "dfs"; var assembly = base.GetAssembly(program.GetSyntaxTree()); AnalysisContext.Create(assembly); SCTEngine.Setup(); SCTEngine.Run(); Assert.AreEqual(1, SCTEngine.NumOfFoundBugs); }
public void Parse(SeekableStreamReader reader, CompilationUnit file, ModuleContainer module) { CSharpParser parser = new CSharpParser(reader, file, module); parser.parse(); }
public static void Main(string[] args) { /* * if (args.Length == 0) { * Console.WriteLine("Please specify the path to a .sln file on the command line"); * * Console.Write("Press any key to continue . . . "); * Console.ReadKey(true); * return; * } * */ List <string> list = new List <string>(); Solution solution = new Solution("/Users/luozhuocheng/IOS/HotFixForUnity/AddMethodToolMac/Console/AddMethod/AddMethod.sln"); //Solution solution = new Solution(args[0]); // foreach (var file in solution.AllFiles) { // var astResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile); // foreach (var invocation in file.SyntaxTree.Descendants.OfType<InvocationExpression>()) { // // Retrieve semantics for the invocation // var rr = astResolver.Resolve(invocation) as InvocationResolveResult; // if (rr == null) { // // Not an invocation resolve result - e.g. could be a UnknownMemberResolveResult instead // continue; // } // if (rr.Member.FullName != "System.String.IndexOf") { // // Invocation isn't a string.IndexOf call // continue; // } // if (rr.Member.Parameters.First().Type.FullName != "System.String") { // // Ignore the overload that accepts a char, as that doesn't take a StringComparison. // // (looking for a char always performs the expected ordinal comparison) // continue; // } // if (rr.Member.Parameters.Last().Type.FullName == "System.StringComparison") { // // Already using the overload that specifies a StringComparison // continue; // } // Console.WriteLine(invocation.GetRegion() + ": " + invocation.GetText()); // file.IndexOfInvocations.Add(invocation); // } // } // Console.WriteLine("Found {0} places to refactor in {1} files.", // solution.AllFiles.Sum(f => f.IndexOfInvocations.Count), // solution.AllFiles.Count(f => f.IndexOfInvocations.Count > 0)); Console.Write("Apply refactorings? "); //string answer = Console.ReadLine(); //if ("yes".Equals(answer, StringComparison.OrdinalIgnoreCase) || "y".Equals(answer, StringComparison.OrdinalIgnoreCase)) { foreach (var file in solution.AllFiles) { // if (file.IndexOfInvocations.Count == 0) // continue; // DocumentScript expects the the AST to stay unmodified (so that it fits // to the document state at the time of the DocumentScript constructor call), // so we call Freeze() to prevent accidental modifications (e.g. forgetting a Clone() call). file.SyntaxTree.Freeze(); // AST resolver used to find context for System.StringComparison generation var compilation = file.Project.Compilation; var astResolver = new CSharpAstResolver(compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile); // Create a document containing the file content: var document = new StringBuilderDocument(file.OriginalText); var formattingOptions = FormattingOptionsFactory.CreateAllman(); var options = new TextEditorOptions(); // using (var script = new DocumentScript(document, formattingOptions, options)) { // foreach (InvocationExpression expr in file.IndexOfInvocations) { // // Generate a reference to System.StringComparison in this context: // var astBuilder = new TypeSystemAstBuilder(astResolver.GetResolverStateBefore(expr)); // IType stringComparison = compilation.FindType(typeof(StringComparison)); // AstType stringComparisonAst = astBuilder.ConvertType(stringComparison); // // // Alternative 1: clone a portion of the AST and modify it // var copy = (InvocationExpression)expr.Clone(); // copy.Arguments.Add(stringComparisonAst.Member("Ordinal")); // script.Replace(expr, copy); // // // // Alternative 2: perform direct text insertion // // int offset = script.GetCurrentOffset(expr.RParToken.StartLocation); // // script.InsertText(offset, ", " + stringComparisonAst.GetText() + ".Ordinal"); // } // } using (var script = new DocumentScript(document, formattingOptions, options)) { CSharpParser parser = new CSharpParser(); //SyntaxTree syntaxTree = parser.Parse(code, srcFilePath); SyntaxTree syntaxTree = file.SyntaxTree; foreach (var classDec in syntaxTree.Descendants.OfType <TypeDeclaration>()) { if (classDec.ClassType == ClassType.Class || classDec.ClassType == ClassType.Struct) { var className = classDec.Name; foreach (var method in classDec.Children.OfType <MethodDeclaration>()) { var returnType = method.ReturnType.ToString(); if (returnType.Contains("IEnumerator") || returnType.Contains("IEnumerable")) // 暂不支持yield! { continue; } Console.WriteLine("className:" + className + " method:" + method.Name); AstNodeCollection <ParameterDeclaration> paramlist = method.Parameters; // // if (FixUtil.Instance.NeedFix("test001.SetName")) // { // FixUtil.Instance.Fix("test001.SetName", this, name); // return; // } //list.Clear(); //list.Add(",this"); string str = ", this"; foreach (ParameterDeclaration param in paramlist) { Console.WriteLine("param " + param.Name); str += string.Format(", {0}", param.Name); } // 。。。。这里找到了方法体! 开始进行插入! // int offset = script.GetCurrentOffset(expr.RParToken.StartLocation); int offset = script.GetCurrentOffset(method.Body.LBraceToken.StartLocation); script.InsertText(offset + 1, "\n" + "\n" + string.Format("if (FixUtil.Instance.NeedFix(\"{0}.{1}\"))\n", className, method.Name) + "{\n" + string.Format(" FixUtil.Instance.Fix(\"{0}.{1}\"{2});\n", className, method.Name, str) + " return;\n" + "}\n"); } } } } File.WriteAllText(Path.ChangeExtension(file.FileName, ".output.cs"), document.Text); } string text = Console.ReadLine(); } }
public void TestActions6Fail() { var test = @" using System; using Microsoft.PSharp; namespace SystematicTesting { class E1 : Event { public E1() : base(1, -1) { } } class E2 : Event { public E2() : base(1, -1) { } } class E3 : Event { public E3() : base(1, -1) { } } class E4 : Event { public E4() : base(1, -1) { } } class Unit : Event { public Unit() : base(1, -1) { } } class Real : Machine { MachineId GhostMachine; [Start] [OnEntry(nameof(EntryInit))] [OnEventGotoState(typeof(E4), typeof(S2))] [OnEventPushState(typeof(Unit), typeof(S1))] [OnEventDoAction(typeof(E2), nameof(Action1))] class Init : MachineState { } void EntryInit() { GhostMachine = this.CreateMachine(typeof(Ghost), this.Id); this.Raise(new Unit()); } [OnEntry(nameof(EntryS1))] class S1 : MachineState { } void EntryS1() { this.Send(GhostMachine, new E1()); } [OnEntry(nameof(EntryS2))] class S2 : MachineState { } void EntryS2() { // this assert is reachable this.Assert(false); } void Action1() { this.Assert((int)this.Payload == 100); // this assert passes this.Send(GhostMachine, new E3()); } } class Ghost : Machine { MachineId RealMachine; [Start] [OnEntry(nameof(EntryInit))] [OnEventGotoState(typeof(E1), typeof(S1))] class Init : MachineState { } void EntryInit() { RealMachine = this.Payload as MachineId; } [OnEntry(nameof(EntryS1))] [OnEventGotoState(typeof(E3), typeof(S2))] class S1 : MachineState { } void EntryS1() { this.Send(RealMachine, new E2(), 100); } [OnEntry(nameof(EntryS2))] class S2 : MachineState { } void EntryS2() { this.Send(RealMachine, new E4()); } } public static class TestProgram { public static void Main(string[] args) { TestProgram.Execute(); Console.ReadLine(); } [Test] public static void Execute() { PSharpRuntime.CreateMachine(typeof(Real)); } } }"; var parser = new CSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), true); var program = parser.Parse(); program.Rewrite(); Configuration.SuppressTrace = true; Configuration.Verbose = 2; Configuration.SchedulingStrategy = "dfs"; var assembly = base.GetAssembly(program.GetSyntaxTree()); AnalysisContext.Create(assembly); SCTEngine.Setup(); SCTEngine.Run(); Assert.AreEqual(1, SCTEngine.NumOfFoundBugs); Assert.AreEqual(5, SCTEngine.ExploredDepth); }
bool IsClasslessCode(string rawCode) { if (ProcessIfMarkedAsClassless(rawCode)) { return(true); } //ensure "one statement - one line" rule string code = new CSharpParser(rawCode).PureCode.Replace("\n", " ").Replace("\r", " ").Replace(";", ";\n"); string line; StringReader sr = new StringReader(code); CodeArea area = CodeArea.unknown; while ((line = sr.ReadLine()) != null) { string clearLine = line.Trim(); if (clearLine.Length == 0) { continue; } while (true) { switch (area) { case CodeArea.unknown: { if (IsUsingDirective(clearLine)) { area = CodeArea.header; continue; } else if (!IsDeclaration(clearLine)) { area = CodeArea.body; continue; } else { area = CodeArea.footer; continue; } } case CodeArea.header: { if (IsUsingDirective(clearLine)) { header.Append(line); header.Append(Environment.NewLine); } else { area = CodeArea.body; continue; } break; } case CodeArea.body: { if (!IsDeclaration(clearLine)) { body.Append(line); body.Append(Environment.NewLine); } else { area = CodeArea.footer; continue; } break; } case CodeArea.footer: { footer.Append(line); footer.Append(Environment.NewLine); break; } } break; } } if (body.Length != 0) { return(true); } else { if (footer.Length == 0) { return(false); } else { //it is either C# or CC# without body string fotterStr = footer.ToString().TrimStart(); if (fotterStr.StartsWith("namespace") && IsToken(fotterStr, 0, "namespace".Length)) { return(false); } else { foreach (string classToken in new string[] { "class", "enum", "struct" }) { int classStart = -1; while ((classStart = fotterStr.IndexOf(classToken, classStart + 1)) != -1) { if (IsToken(fotterStr, classStart, classToken.Length)) { string decorations = fotterStr.Substring(0, classStart); if (decorations.IndexOfAny(";{}()".ToCharArray()) != -1) { break; } else { return(false); } } } } return(true); } } } }
void ScanPreProcessorIf(int textOffset, ref int i) { var end = CurText.Length; int idx = 0; while ((idx = CurText.IndexOf('/', idx)) >= 0 && idx + 1 < CurText.Length) { var next = CurText [idx + 1]; if (next == '/') { end = idx - 1; break; } idx++; } int length = end - textOffset; string parameter = CurText.Substring(textOffset + 3, length - 3); AstNode expr = new CSharpParser().ParseExpression(parameter); bool result = false; if (expr != null && !expr.IsNull) { object o = expr.AcceptVisitor(new ConditinalExpressionEvaluator(doc, Defines), null); if (o is bool) { result = (bool)o; } } foreach (Span span in spanStack) { if (span is ElseBlockSpan) { result &= ((ElseBlockSpan)span).IsValid; break; } if (span is IfBlockSpan) { result &= ((IfBlockSpan)span).IsValid; break; } if (span is ElseIfBlockSpan) { result &= ((ElseIfBlockSpan)span).IsValid; break; } } var ifBlockSpan = new IfBlockSpan(result); foreach (Span span in spanStack) { if (span is AbstractBlockSpan) { var parentBlock = (AbstractBlockSpan)span; ifBlockSpan.Disabled = parentBlock.Disabled || !parentBlock.IsValid; break; } } FoundSpanBegin(ifBlockSpan, i, length); i += length - 1; }
public void TestNondet1() { var test = @" using System; using System.Collections.Generic; using Microsoft.PSharp; namespace SystematicTesting { class Unit : Event { } class UserEvent : Event { } class Done : Event { } class Loop : Event { } class Waiting : Event { } class Computing : Event { } class EventHandler : Machine { List<MachineId> Workers; [Start] [OnEntry(nameof(InitOnEntry))] [OnEventGotoState(typeof(Unit), typeof(WaitForUser))] class Init : MachineState { } void InitOnEntry() { this.CreateMonitor(typeof(WatchDog)); this.Raise(new Unit()); } [OnEntry(nameof(WaitForUserOnEntry))] [OnEventGotoState(typeof(UserEvent), typeof(HandleEvent))] class WaitForUser : MachineState { } void WaitForUserOnEntry() { this.Monitor<WatchDog>(new Waiting()); this.Send(this.Id, new UserEvent()); } [OnEntry(nameof(HandleEventOnEntry))] [OnEventGotoState(typeof(Done), typeof(WaitForUser))] [OnEventGotoState(typeof(Loop), typeof(HandleEvent))] class HandleEvent : MachineState { } void HandleEventOnEntry() { this.Monitor<WatchDog>(new Computing()); if (this.Nondet()) { this.Send(this.Id, new Done()); } else { this.Send(this.Id, new Loop()); } } } class WatchDog : Monitor { List<MachineId> Workers; [Start] [Cold] [OnEventGotoState(typeof(Waiting), typeof(CanGetUserInput))] [OnEventGotoState(typeof(Computing), typeof(CannotGetUserInput))] class CanGetUserInput : MonitorState { } [Hot] [OnEventGotoState(typeof(Waiting), typeof(CanGetUserInput))] [OnEventGotoState(typeof(Computing), typeof(CannotGetUserInput))] class CannotGetUserInput : MonitorState { } } public static class TestProgram { public static void Main(string[] args) { TestProgram.Execute(); Console.ReadLine(); } [Test] public static void Execute() { PSharpRuntime.CreateMachine(typeof(EventHandler)); } } }"; var parser = new CSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), true); var program = parser.Parse(); program.Rewrite(); var sctConfig = new DynamicAnalysisConfiguration(); sctConfig.SuppressTrace = true; sctConfig.Verbose = 3; sctConfig.CheckLiveness = true; sctConfig.CacheProgramState = true; Output.Debugging = true; var assembly = base.GetAssembly(program.GetSyntaxTree()); var context = AnalysisContext.Create(sctConfig, assembly); var sctEngine = SCTEngine.Create(context).Run(); var bugReport = "Monitor 'WatchDog' detected infinite execution that violates a liveness property."; Assert.AreEqual(bugReport, sctEngine.BugReport); }
public FindFormalInputOfMethod(CSharpParser parser) { this.parser = parser; }
public void TestSEMOneMachine34() { var test = @" using System; using System.Collections.Generic; using Microsoft.PSharp; namespace SystematicTesting { class E1 : Event { } class E2 : Event { } class E3 : Event { } class E4 : Event { } class MachOS : Machine { int Int; bool Bool; MachineId mach; Dictionary<int, int> m; List<bool> s; [Start] [OnEntry(nameof(EntryInit))] [OnEventDoAction(typeof(E1), nameof(Foo1))] [OnEventDoAction(typeof(E2), nameof(Foo2))] [OnEventDoAction(typeof(E3), nameof(Foo3))] [OnEventDoAction(typeof(E4), nameof(Foo4))] class Init : MachineState { } void EntryInit() { m = new Dictionary<int, int>(); s = new List<bool>(); m.Add(0, 1); m.Add(1, 2); s.Add(true); s.Add(false); s.Add(true); this.Send(this.Id, new E1(), Tuple.Create(1, true)); this.Send(this.Id, new E2(), 0, false); this.Send(this.Id, new E3(), 1); this.Send(this.Id, new E4(), Tuple.Create(m, s)); } void Foo1() { Int = (int)(this.Payload as Tuple<int, bool>).Item1; this.Assert(Int == 1); Bool = (bool)(this.Payload as Tuple<int, bool>).Item2; this.Assert(Bool == true); } void Foo2() { Int = (int)(this.Payload as object[])[0]; this.Assert(Int == 0); Bool = (bool)(this.Payload as object[])[1]; this.Assert(Bool == false); } void Foo3() { Int = (int)this.Payload; this.Assert(Int == 1); } void Foo4() { Int = ((this.Payload as Tuple<Dictionary<int, int>, List<bool>>).Item1 as Dictionary<int, int>)[0]; this.Assert(Int == 1); Bool = ((this.Payload as Tuple<Dictionary<int, int>, List<bool>>).Item2 as List<bool>)[2]; this.Assert(Bool == true); } } public static class TestProgram { public static void Main(string[] args) { TestProgram.Execute(); Console.ReadLine(); } [Test] public static void Execute() { PSharpRuntime.CreateMachine(typeof(MachOS)); } } }"; var parser = new CSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), true); var program = parser.Parse(); program.Rewrite(); var sctConfig = new DynamicAnalysisConfiguration(); sctConfig.SuppressTrace = true; sctConfig.Verbose = 2; sctConfig.SchedulingStrategy = SchedulingStrategy.DFS; sctConfig.SchedulingIterations = 100; var assembly = base.GetAssembly(program.GetSyntaxTree()); var context = AnalysisContext.Create(sctConfig, assembly); var sctEngine = SCTEngine.Create(context).Run(); Assert.AreEqual(0, sctEngine.NumOfFoundBugs); }
public FindLiteralofMethod(CSharpParser parser, List <string> listVal) { this.parser = parser; this.listVal = listVal; this.isConst = false; }
// // Parses the string @input and returns a CSharpParser if succeeful. // // if @silent is set to true then no errors are // reported to the user. This is used to do various calls to the // parser and check if the expression is parsable. // // @partial_input: if @silent is true, then it returns whether the // parsed expression was partial, and more data is needed // CSharpParser ParseString(ParseMode mode, string input, out bool partial_input) { partial_input = false; Reset(); var enc = ctx.Settings.Encoding; var s = new MemoryStream(enc.GetBytes(input)); SeekableStreamReader seekable = new SeekableStreamReader(s, enc); InputKind kind = ToplevelOrStatement(seekable); if (kind == InputKind.Error) { if (mode == ParseMode.ReportErrors) { ctx.Report.Error(-25, "Detection Parsing Error"); } partial_input = false; return(null); } if (kind == InputKind.EOF) { if (mode == ParseMode.ReportErrors) { Console.Error.WriteLine("Internal error: EOF condition should have been detected in a previous call with silent=true"); } partial_input = true; return(null); } seekable.Position = 0; source_file.DeclarationFound = false; CSharpParser parser = new CSharpParser(seekable, source_file, new ParserSession()); if (kind == InputKind.StatementOrExpression) { parser.Lexer.putback_char = Tokenizer.EvalStatementParserCharacter; ctx.Settings.StatementMode = true; } else { parser.Lexer.putback_char = Tokenizer.EvalCompilationUnitParserCharacter; ctx.Settings.StatementMode = false; } if (mode == ParseMode.GetCompletions) { parser.Lexer.CompleteOnEOF = true; } ReportPrinter old_printer = null; if ((mode == ParseMode.Silent || mode == ParseMode.GetCompletions)) { old_printer = ctx.Report.SetPrinter(new StreamReportPrinter(TextWriter.Null)); } try { parser.parse(); } finally { if (ctx.Report.Errors != 0) { if (mode != ParseMode.ReportErrors && parser.UnexpectedEOF) { partial_input = true; } if (parser.undo != null) { parser.undo.ExecuteUndo(); } parser = null; } if (old_printer != null) { ctx.Report.SetPrinter(old_printer); } } return(parser); }
public FindGlobalVariable(CSharpParser parser) { this.parser = parser; }
public void SetUp() { var unresolvedFile = new CSharpParser().Parse(corlib, "corlib.cs").ToTypeSystem(); compilation = new CSharpProjectContent().SetAssemblyName("mscorlib").AddOrUpdateFiles(unresolvedFile).CreateCompilation(); }
public override IEnumerable <MemberReference> FindReferences(Project project, IProjectContent content, IEnumerable <FilePath> possibleFiles, IEnumerable <object> members) { if (project == null) { throw new ArgumentNullException("project", "Project not set."); } if (content == null) { throw new ArgumentNullException("content", "Project content not set."); } SetPossibleFiles(possibleFiles); SetSearchedMembers(members); var scopes = searchedMembers.Select(e => refFinder.GetSearchScopes(e as IEntity)); var compilation = TypeSystemService.GetCompilation(project); List <MemberReference> refs = new List <MemberReference> (); foreach (var opendoc in openDocuments) { foreach (var newRef in FindInDocument(opendoc.Item2)) { if (newRef == null || refs.Any(r => r.FileName == newRef.FileName && r.Region == newRef.Region)) { continue; } refs.Add(newRef); } } foreach (var file in files) { string text = Mono.TextEditor.Utils.TextFileUtility.ReadAllText(file); if (memberName != null && text.IndexOf(memberName, StringComparison.Ordinal) < 0 && (keywordName == null || text.IndexOf(keywordName, StringComparison.Ordinal) < 0)) { continue; } using (var editor = TextEditorData.CreateImmutable(text)) { editor.Document.FileName = file; var unit = new CSharpParser().Parse(editor); if (unit == null) { continue; } var storedFile = content.GetFile(file); var parsedFile = storedFile as CSharpParsedFile; if (parsedFile == null && storedFile is ParsedDocumentDecorator) { parsedFile = ((ParsedDocumentDecorator)storedFile).ParsedFile as CSharpParsedFile; } if (parsedFile == null) { // for fallback purposes - should never happen. parsedFile = unit.ToTypeSystem(); content = content.UpdateProjectContent(content.GetFile(file), parsedFile); compilation = content.CreateCompilation(); } foreach (var scope in scopes) { refFinder.FindReferencesInFile( scope, parsedFile, unit, compilation, (astNode, result) => { var newRef = GetReference(result, astNode, file, editor); if (newRef == null || refs.Any(r => r.FileName == newRef.FileName && r.Region == newRef.Region)) { return; } refs.Add(newRef); }, CancellationToken.None ); } } } return(refs); }
/// <summary> /// Parses the specified file /// </summary> /// <param name="f">File information.</param> /// <param name="s">Stream with the file code.</param> /// <param name="dynamic">Using "dynamic" to refer to a "dynamic var"</param> private void parseFile(FileInfo f, Stream s, bool dynamic) { ICSharpLexer antlrLexer; ICSharpParser parser; TokenStreamHiddenTokenFilter filter; try { TokenStream lexer; // Create a scanner that reads from the input stream passed to us if (dynamic) { antlrLexer = new CSharpLexerDynamic(new StreamReader(s)); } else { antlrLexer = new CSharpLexer(new StreamReader(s)); } // Define a selector that can switch from the C# codelexer to the C# preprocessor lexer TokenStreamSelector selector = new TokenStreamSelector(); antlrLexer.Selector = selector; antlrLexer.setFilename(f.Name); CSharpPreprocessorLexer preproLexer = new CSharpPreprocessorLexer(antlrLexer.getInputState()); preproLexer.Selector = selector; CSharpPreprocessorHooverLexer hooverLexer = new CSharpPreprocessorHooverLexer(antlrLexer.getInputState()); hooverLexer.Selector = selector; // use the special token object class antlrLexer.setTokenCreator(new CustomHiddenStreamToken.CustomHiddenStreamTokenCreator()); antlrLexer.setTabSize(1); preproLexer.setTokenCreator(new CustomHiddenStreamToken.CustomHiddenStreamTokenCreator()); preproLexer.setTabSize(1); hooverLexer.setTokenCreator(new CustomHiddenStreamToken.CustomHiddenStreamTokenCreator()); hooverLexer.setTabSize(1); // notify selector about various lexers; name them for convenient reference later selector.addInputStream(antlrLexer, "codeLexer"); selector.addInputStream(preproLexer, "directivesLexer"); selector.addInputStream(hooverLexer, "hooverLexer"); selector.select("codeLexer"); // start with main the CSharp code lexer lexer = selector; // create the stream filter; hide WS and SL_COMMENT filter = new TokenStreamHiddenTokenFilter(lexer); filter.hide(CSharpTokenTypes.WHITESPACE); filter.hide(CSharpTokenTypes.NEWLINE); filter.hide(CSharpTokenTypes.ML_COMMENT); filter.hide(CSharpTokenTypes.SL_COMMENT); //------------------------------------------------------------------ // Create a parser that reads from the scanner if (dynamic) { parser = new CSharpParserDynamic(filter); DynVarManager.DynamicOption = true; } else { parser = new CSharpParser(filter); } parser.setFilename(f.FullName); //parser.setFilename(f.Name); // Start parsing at the compilationUnit rule long startTime = DateTime.Now.Ticks; this.astList.Add(parser.compilationUnit()); #if DEBUG double elapsedTime = ((DateTime.Now.Ticks - startTime) / TimeSpan.TicksPerMillisecond) / 1000.0; ConsoleColor previousColor = Console.ForegroundColor; Console.ForegroundColor = ConsoleColor.DarkGray; System.Console.Out.WriteLine("Parsed {0} in: {1} seconds.", f.Name, elapsedTime); Console.ForegroundColor = previousColor; #endif } catch (RecognitionException e) { ErrorManager.Instance.NotifyError(new ParserError(new Location(e.fileName, e.line, e.column), e.Message)); } }
public IEnumerable <AstNode> FindUsageNodes(Request request) { var res = _parser.ParsedContent(request.Buffer, request.FileName); var loc = new TextLocation(request.Line, request.Column); _result = new ConcurrentBag <AstNode>(); var findReferences = new FindReferences { FindCallsThroughInterface = true, FindCallsThroughVirtualBaseMethod = true, FindTypeReferencesEvenIfAliased = false, }; ResolveResult resolveResult = ResolveAtLocation.Resolve(res.Compilation, res.UnresolvedFile, res.SyntaxTree, loc); if (resolveResult is LocalResolveResult) { var variable = (resolveResult as LocalResolveResult).Variable; findReferences.FindLocalReferences(variable, res.UnresolvedFile, res.SyntaxTree, res.Compilation, (node, rr) => _result.Add(node.GetDefinition()), CancellationToken.None); } else { IEntity entity = null; IEnumerable <IList <IFindReferenceSearchScope> > searchScopes = null; if (resolveResult is TypeResolveResult) { var type = (resolveResult as TypeResolveResult).Type; entity = type.GetDefinition(); ProcessTypeResults(type); searchScopes = new[] { findReferences.GetSearchScopes(entity) }; } if (resolveResult is MemberResolveResult) { entity = (resolveResult as MemberResolveResult).Member; if (entity.SymbolKind == SymbolKind.Constructor) { // process type instead var type = entity.DeclaringType; entity = entity.DeclaringTypeDefinition; ProcessTypeResults(type); searchScopes = new[] { findReferences.GetSearchScopes(entity) }; } else { ProcessMemberResults(resolveResult); var member = (resolveResult as MemberResolveResult).Member; var members = MemberCollector.CollectMembers(_solution, member, false); searchScopes = members.Select(findReferences.GetSearchScopes); } } if (entity == null) { return(_result); } var projectsThatReferenceUsage = _projectFinder.FindProjectsReferencing(entity.Compilation.TypeResolveContext); foreach (var project in projectsThatReferenceUsage) { var pctx = project.ProjectContent.CreateCompilation(); var interesting = (from file in project.Files select(file.ParsedFile as CSharpUnresolvedFile)).ToList(); Parallel.ForEach(interesting.Distinct(), file => { string text = _solution.GetFile(file.FileName.LowerCaseDriveLetter()).Content.Text; SyntaxTree unit; if (project.CompilerSettings != null) { unit = new CSharpParser(project.CompilerSettings).Parse(text, file.FileName); } else { unit = new CSharpParser().Parse(text, file.FileName); } foreach (var scope in searchScopes) { findReferences.FindReferencesInFile(scope, file, unit, pctx, (node, rr) => _result.Add(node.GetIdentifier()), CancellationToken.None); } }); } } return(_result); }
public void TestPushImplicitPopWithRaise() { var test = @" using System; using Microsoft.PSharp; namespace SystematicTesting { class E1 : Event { public E1() : base(1, -1) { } } class E2 : Event { public E2() : base(1, -1) { } } class E3 : Event { public E3() : base(1, -1) { } } class Real1 : Machine { bool test = false; [Start] [OnEntry(nameof(EntryInit))] [OnExit(nameof(ExitInit))] [OnEventGotoState(typeof(E1), typeof(Init))] [OnEventPushState(typeof(E2), typeof(S1))] [OnEventDoAction(typeof(E3), nameof(Action1))] class Init : MachineState { } void EntryInit() { this.Send(this.Id, new E1()); } void ExitInit() { this.Send(this.Id, new E2()); } [OnEntry(nameof(EntryS1))] class S1 : MachineState { } void EntryS1() { test = true; this.Raise(new E1()); } void Action1() { } } public static class TestProgram { public static void Main(string[] args) { TestProgram.Execute(); Console.ReadLine(); } [Test] public static void Execute() { PSharpRuntime.CreateMachine(typeof(Real1)); } } }"; var parser = new CSharpParser(new PSharpProject(), SyntaxFactory.ParseSyntaxTree(test), true); var program = parser.Parse(); program.Rewrite(); Configuration.SuppressTrace = true; Configuration.Verbose = 2; var assembly = base.GetAssembly(program.GetSyntaxTree()); AnalysisContext.Create(assembly); SCTEngine.Setup(); SCTEngine.Run(); Assert.AreEqual(1, SCTEngine.NumOfFoundBugs); }
public static VariableInitializer GetVariableDeclarationForLinqMethods(string query, bool requiresSelectNewAnonymousType) { try { var parser = new CSharpParser(); var block = parser.ParseStatements(ToQueryStatement(query)).ToList(); if (block.Count == 0 || parser.HasErrors) { var errs = string.Join(Environment.NewLine, parser.Errors.Select(x => x.Region + ": " + x.ErrorType + " - " + x.Message)); throw new InvalidOperationException("Could not understand query: \r\n" + errs); } var declaration = block[0] as VariableDeclarationStatement; if (declaration == null) { throw new InvalidOperationException("Only local variable declaration are allowed"); } if (declaration.Variables.Count != 1) { throw new InvalidOperationException("Only one variable declaration is allowed"); } var variable = declaration.Variables.First(); if (variable.Initializer as InvocationExpression == null) { throw new InvalidOperationException("Variable declaration must have an initializer which is a method invocation expression"); } var targetObject = ((InvocationExpression)variable.Initializer).Target as MemberReferenceExpression; if (targetObject == null) { throw new InvalidOperationException("Variable initializer must be invoked on a method reference expression"); } if (targetObject.MemberName != "Select" && targetObject.MemberName != "SelectMany") { throw new InvalidOperationException("Variable initializer must end with a select call"); } var lambdaExpression = AsLambdaExpression(((InvocationExpression)variable.Initializer).Arguments.Last()); if (lambdaExpression == null) { throw new InvalidOperationException("Variable initializer select must have a lambda expression"); } variable.AcceptVisitor(new TransformNullCoalescingOperatorTransformer(), null); variable.AcceptVisitor(new DynamicExtensionMethodsTranslator(), null); variable.AcceptVisitor(new TransformDynamicLambdaExpressions(), null); variable.AcceptVisitor(new TransformDynamicInvocationExpressions(), null); variable.AcceptVisitor(new TransformObsoleteMethods(), null); var expressionBody = GetAnonymousCreateExpression(lambdaExpression.Body); var anonymousTypeCreateExpression = expressionBody as AnonymousTypeCreateExpression; if (anonymousTypeCreateExpression == null && requiresSelectNewAnonymousType) { throw new InvalidOperationException("Variable initializer select must have a lambda expression with an object create expression"); } var objectCreateExpression = expressionBody as ObjectCreateExpression; if (objectCreateExpression != null && requiresSelectNewAnonymousType) { throw new InvalidOperationException("Variable initializer select must have a lambda expression creating an anonymous type but returning " + objectCreateExpression.Type); } return(variable); } catch (Exception e) { throw new InvalidOperationException("Could not understand query: " + e.Message, e); } }
public CustomCSharpListener(CSharpParser parser) { _parser = parser; _interfaceExtractRule = new InterfaceExtractorRule(_parser.InputStream as ITokenStream); //_interfacePreProcTemplate = new StringBuilder(); }