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);
}
