private static InvocationContext CreateContext_CS() { const string source = @"class X { public Item Foo() { var ret = new Item(); ret = ret.Aaa(); return ret.Bbb().Ccc(); } public Item Boo() { var arr = new Item[] {new Item()}; return arr[0].Ddd(); } }; class Item { public Item Aaa() { return this;} public Item Bbb() { return this;} public Item Ccc() { return this;} public Item Ddd() { return this;} }"; var snippet = new SnippetCompiler(source, false, AnalyzerLanguage.CSharp); return(new InvocationContext(FindMethodInvocation_CS(snippet.SyntaxTree, "Ccc"), "Ccc", snippet.SemanticModel)); }
private static InvocationContext CreateContext() { const string source = @"class X{void Foo(object x){x.ToString()}};"; var snippet = new SnippetCompiler(source, true, AnalyzerLanguage.CSharp); return(new InvocationContext(snippet.SyntaxTree.GetRoot().DescendantNodes().OfType <InvocationExpressionSyntax>().Single(), "ToString", snippet.SemanticModel)); }
private static FieldAccessContext CreateContext <TSyntaxNodeType>(string testInput, string fieldName, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode { var testCode = new SnippetCompiler(testInput, true, language); var node = testCode.GetNodes <TSyntaxNodeType>().First(x => x.ToString() == fieldName); return(new FieldAccessContext(testCode.CreateAnalysisContext(node), fieldName)); }
private static PropertyAccessContext CreateContext <TSyntaxNodeType>(string testInput, string propertyName, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode { var testCode = new SnippetCompiler(testInput, false, language); var expression = testCode.GetNodes <TSyntaxNodeType>().First(); return(new PropertyAccessContext(expression, propertyName, testCode.SemanticModel)); }
private static MethodDeclarationContext CreateContext(string testInput, AnalyzerLanguage language, string methodName) { var testCode = new SnippetCompiler(testInput, false, language); var symbol = testCode.GetMethodSymbol("Sample." + methodName); return(new MethodDeclarationContext(symbol, testCode.SemanticModel.Compilation)); }
public void CheckMatch_InterfaceMethods_NameMatchButNotOverride_VB() { const string code = @" Namespace Test NotInheritable Class Class1 Implements System.IDisposable Public Sub Test() Dispose(42) ' <-- FALSE POSITIVE: shouldn't match since not implementing IDisposable.Dispose End Sub Public Sub Dispose(Data As Integer) ' no-op End Sub Private Sub Dispose() Implements System.IDisposable.Dispose ' no-op End Sub End Class End Namespace "; var snippet = new SnippetCompiler(code, false, AnalyzerLanguage.VisualBasic); DoCheckMatch_InterfaceMethods(snippet); }
public ActionResult SubmitSnippet(String usingDirectives, String snippetClasses, String snippetMain, String compilerVersion) { try { var snippetSource = new System.Text.StringBuilder(); snippetSource.Append(SnippetUsing); snippetSource.Append(usingDirectives); snippetSource.Append(SnippetClassHeader); snippetSource.Append(snippetClasses); snippetSource.Append(SnippetMainHeader()); snippetSource.Append(snippetMain); snippetSource.Append(SnippetFooter); var snippetAssembly = Pumpkin.SnippetCompiler.CompileWithCSC( snippetSource.ToString(), Server.MapPath(@"~\App_Data"), compilerVersion); if (snippetAssembly.success) { var patchedAssembly = SnippetCompiler.PatchAssembly(snippetAssembly.assemblyBytes, "Snippets." + SnippetData.SnippetTypeName); repository.Save(usingDirectives, snippetClasses, snippetMain, patchedAssembly, compilerVersion); return(new HttpStatusCodeResult(204)); } else { Response.StatusCode = 400; return(Json(snippetAssembly.errors)); } } catch (Exception ex) { Response.StatusCode = 500; return(Json(new string[] { "Internal error: ", ex.Message })); } }
public void ImplicitObjectCreationSyntax() { const string code = @" public class A { public int X; public A(int y) { } } public class B { void Foo() { A bar =new(1) { X = 2 }; } }"; var snippet = new SnippetCompiler(code); var syntaxTree = snippet.SyntaxTree; var objectCreation = (ImplicitObjectCreationExpressionSyntaxWrapper)syntaxTree.GetRoot().DescendantNodes().First((node => node.IsKind(SyntaxKindEx.ImplicitObjectCreationExpression))); var wrapper = ObjectCreationFactory.Create(objectCreation); wrapper.Expression.Should().BeEquivalentTo(objectCreation.SyntaxNode); wrapper.Initializer.Should().BeEquivalentTo(objectCreation.Initializer); wrapper.ArgumentList.Should().BeEquivalentTo(objectCreation.ArgumentList); wrapper.TypeAsString(snippet.SemanticModel).Should().Be("A"); }
private static PropertyAccessContext CreateContext <TSyntaxNodeType>(string testInput, string propertyName, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode { var testCode = new SnippetCompiler(testInput, false, language); var node = testCode.GetNodes <TSyntaxNodeType>().First(); return(new PropertyAccessContext(testCode.CreateAnalysisContext(node), propertyName)); }
private static ElementAccessContext CreateContext <TSyntaxNodeType>(string testInput, int skip, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode { var testCode = new SnippetCompiler(testInput, true, language); var node = testCode.GetNodes <TSyntaxNodeType>().Skip(skip).First(); var context = new ElementAccessContext(testCode.CreateAnalysisContext(node)); return(context); }
private static ObjectCreationContext CreateContext <TSyntaxNodeType>(string testInput, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode { var testCode = new SnippetCompiler(testInput, true, language); var node = testCode.GetNodes <TSyntaxNodeType>().First(); var context = new ObjectCreationContext(testCode.CreateAnalysisContext(node)); return(context); }
public void GivenNonConstructor_ThrowsException() { var snippet = new SnippetCompiler("public class A{}"); var classDeclaration = snippet.SyntaxTree.GetRoot().DescendantNodes().OfType <ClassDeclarationSyntax>().First(); Action action = () => { ObjectCreationFactory.Create(classDeclaration); }; action.Should().Throw <InvalidOperationException>().WithMessage("Unexpected type: ClassDeclarationSyntax"); }
private static InvocationContext CreateContext <TSyntaxNodeType>(string testInput, string methodName, AnalyzerLanguage language, int skip = 0) where TSyntaxNodeType : SyntaxNode { var testCode = new SnippetCompiler(testInput, true, language); var invocationSyntaxNode = testCode.GetNodes <TSyntaxNodeType>().Skip(skip).First(); var context = new InvocationContext(invocationSyntaxNode, methodName, testCode.SemanticModel); return(context); }
private static void CheckMatch(bool checkDerived, bool expectedOutcome, InvocationContext invocationContext, SnippetCompiler snippet, params MemberDescriptor[] targetMethodSignatures) { var result = MemberDescriptor.MatchesAny(invocationContext.MethodName, invocationContext.MethodSymbol, checkDerived, false, targetMethodSignatures); result.Should().Be(expectedOutcome); }
private static BaseTypeContext CreateContext <TSyntaxNodeType>(string testInput, AnalyzerLanguage language, Func <TSyntaxNodeType, IEnumerable <SyntaxNode> > baseTypeNodes) where TSyntaxNodeType : SyntaxNode { var testCode = new SnippetCompiler(testInput, false, language); var node = testCode.GetNodes <TSyntaxNodeType>().Single(); return(new BaseTypeContext(testCode.CreateAnalysisContext(node), baseTypeNodes(node))); }
private static ObjectCreationContext CreateContext <TSyntaxNodeType>(string testInput, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode { var testCode = new SnippetCompiler(testInput, false, language); var objectCreationSyntaxNode = testCode.GetNodes <TSyntaxNodeType>().First(); var context = new ObjectCreationContext(objectCreationSyntaxNode, testCode.SemanticModel); return(context); }
private static void DoCheckMatch_InterfaceMethods(SnippetCompiler snippet) { var dispose = new MemberDescriptor(KnownType.System_IDisposable, "Dispose"); var callToDispose = CreateContextForMethod("Class1.Dispose", snippet); // Exact match should not match, but matching "derived" methods should CheckExactMethod(false, callToDispose, dispose); CheckIsMethodOrDerived(true, callToDispose, dispose); }
public void CecilWhitelistAssembly() { var snippetSource = File.ReadAllText(@"..\..\Tests\CreateObjectWithActivator.cs"); var snippetAssembly = Pumpkin.SnippetCompiler.CompileWithCSC(snippetSource, Path.GetTempPath()); var whiteList = new List <ListEntry> { new ListEntry("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089") }; Assert.IsTrue(SnippetCompiler.CheckAssemblyAgainstWhitelist(snippetAssembly.assemblyBytes, whiteList)); }
public void GivenImplicitObjectCreationSyntaxWithMissingType_HasEmptyType() { const string code = @" public class B { void Foo() { var bar = new(); } }"; var snippet = new SnippetCompiler(code, true, AnalyzerLanguage.CSharp); var syntaxTree = snippet.SyntaxTree; var objectCreation = (ImplicitObjectCreationExpressionSyntaxWrapper)syntaxTree.GetRoot().DescendantNodes().First((node => node.IsKind(SyntaxKindEx.ImplicitObjectCreationExpression))); var wrapper = ObjectCreationFactory.Create(objectCreation); wrapper.TypeAsString(snippet.SemanticModel).Should().BeEmpty(); }
public void MatchesAny_AndCheckingOverrides_DoesMatchOverrides_VB() { const string code = @" Imports System.Xml Namespace Test Class Class1 Public Sub DoStuff(node As XmlNode, doc As XmlDocument) node.WriteTo(Nothing) doc.WriteTo(Nothing) End Sub End Class End Namespace "; var snippet = new SnippetCompiler(code, false, AnalyzerLanguage.VisualBasic, MetadataReferenceFacade.SystemXml); CheckMatchesAny_AndCheckingOverrides_DoesMatchOverrides(snippet); }
public void GetMethodDeclarations_SingleMethod_ReturnsMethod() { const string code = @" namespace Test { class TestClass { private void WriteLine() {} } } "; var snippet = new SnippetCompiler(code); var typeDeclaration = snippet.SyntaxTree.GetRoot().DescendantNodes().OfType <TypeDeclarationSyntax>().Single(); typeDeclaration.GetMethodDeclarations().Single().Identifier.Text.Should().Be("WriteLine"); }
public void ExactMatch_DoesNotMatchOverrides_VB() { var code = @" Imports System.Xml Namespace Test Class Class1 Public Sub DoStuff(node As XmlNode, doc As XmlDocument) node.WriteTo(Nothing) doc.WriteTo(Nothing) End Sub End Class End Namespace "; var snippet = new SnippetCompiler(code, false, AnalyzerLanguage.VisualBasic, MetadataReferenceFacade.GetSystemXml()); CheckExactMatch_DoesNotMatchOverrides(snippet); }
private static void CheckMatchesAny_AndCheckingOverrides_DoesMatchOverrides(SnippetCompiler snippet) { // XmlDocument derives from XmlNode var nodeWriteTo = new MemberDescriptor(KnownType.System_Xml_XmlNode, "WriteTo"); var docWriteTo = new MemberDescriptor(KnownType.System_Xml_XmlDocument, "WriteTo"); // 1. Call to node.WriteTo should only match for XmlNode var callToNodeWriteTo = CreateContextForMethod("XmlNode.WriteTo", snippet); CheckIsMethodOrDerived(true, callToNodeWriteTo, nodeWriteTo); CheckIsMethodOrDerived(false, callToNodeWriteTo, docWriteTo); // 2. Call to doc.WriteTo should match for XmlDocument and XmlNode var callToDocWriteTo = CreateContextForMethod("XmlDocument.WriteTo", snippet); CheckIsMethodOrDerived(true, callToDocWriteTo, nodeWriteTo); CheckIsMethodOrDerived(true, callToDocWriteTo, docWriteTo); }
public static void ClassInit(TestContext context) { const string code = @" namespace Test { using System.Xml; class Class1 { public void DoStuff(XmlNode node) { node.CloneNode(true); } } } "; var snippet = new SnippetCompiler(code, MetadataReferenceFacade.SystemXml); xmlNodeCloneNodeInvocationContext = CreateContextForMethod("XmlNode.CloneNode", snippet); }
private static void CheckExactMatchOnly_OverridesAreNotMatched(SnippetCompiler snippet) { // Testing for calls to Console.WriteLine var targetMethodSignature = new MemberDescriptor(KnownType.System_Console, "WriteLine"); // 1. Should match Console.WriteLine var callToConsoleWriteLine = CreateContextForMethod("Console.WriteLine", snippet); CheckExactMethod(true, callToConsoleWriteLine, targetMethodSignature); // 2. Should not match call to xxx.WriteLine var callClass1WriteLine = CreateContextForMethod("Class1.WriteLine", snippet); CheckExactMethod(false, callClass1WriteLine, new MemberDescriptor(KnownType.System_Console, "Foo"), targetMethodSignature, new MemberDescriptor(KnownType.System_Data_DataSet, ".ctor")); // 3. Should match if Console.WriteLine is in the list of candidates CheckExactMethod(false, callClass1WriteLine, targetMethodSignature); }
private static InvocationContext CreateContext_VB() { const string source = @"Class X Function Foo() As Item Dim Ret As New Item() Ret = Ret.Aaa() Return Ret.Bbb().Ccc() End Function Function Boo() As Item Dim Arr() As Item = {New Item} Return Arr(0).Ddd() End Function End Class Class Item Public Function Aaa() As Item Return Me End Function Public Function Bbb() As Item Return Me End Function Public Function Ccc() As Item Return Me End Function Public Function Ddd() As Item Return Me End Function End Class"; var snippet = new SnippetCompiler(source, false, AnalyzerLanguage.VisualBasic); return(new InvocationContext(FindMethodInvocation_VB(snippet.SyntaxTree, "Ccc"), "Ccc", snippet.SemanticModel)); }
public void CheckMatch_InterfaceMethods_CS() { const string code = @" namespace Test { sealed class Class1 : System.IDisposable { public void Test() { this.Dispose(); } public void Dispose() { /* no-op */ } } } "; var snippet = new SnippetCompiler(code); DoCheckMatch_InterfaceMethods(snippet); }
public void ExactMatchOnly_OverridesAreNotMatched_CS() { const string code = @" namespace Test { class Class1 { public void DoStuff() { System.Console.WriteLine(); this.WriteLine(); } private void WriteLine() {} } } "; var snippet = new SnippetCompiler(code); CheckExactMatchOnly_OverridesAreNotMatched(snippet); }
public void ExactMatchOnly_OverridesAreNotMatched_VB() { const string code = @" Namespace Test Class Class1 Public Sub DoStuff() System.Console.WriteLine() Me.WriteLine() End Sub Private Sub WriteLine() ' empty End Sub End Class End Namespace "; var snippet = new SnippetCompiler(code, false, AnalyzerLanguage.VisualBasic); CheckExactMatchOnly_OverridesAreNotMatched(snippet); }
public void MatchesAny_AndCheckingOverrides_DoesMatchOverrides_CS() { const string code = @" namespace Test { using System.Xml; class Class1 { public void DoStuff(XmlNode node, XmlDocument doc) { node.WriteTo(null); doc.WriteTo(null); } } } "; var snippet = new SnippetCompiler(code, MetadataReferenceFacade.SystemXml); CheckMatchesAny_AndCheckingOverrides_DoesMatchOverrides(snippet); }