public void CrossLanguageException()
{
var csharpTree = CSharpSyntaxTree.ParseText("class A { }");
var vbTree = VisualBasicSyntaxTree.ParseText(
@"Class A
End Class
"
);
var csc =
CSharpCompilation.Create(
"CS",
new[] { csharpTree },
new MetadataReference[] { TestBase.MscorlibRef }
) as Compilation;
var Ac = csc.GlobalNamespace.GetMembers("A").First() as INamedTypeSymbol;
var vbc =
VisualBasicCompilation.Create(
"VB",
new[] { vbTree },
new MetadataReference[] { TestBase.MscorlibRef }
) as Compilation;
var Av = vbc.GlobalNamespace.GetMembers("A").First() as INamedTypeSymbol;
Assert.Throws <ArgumentException>(() => csc.IsSymbolAccessibleWithin(Av, Av));
Assert.Throws <ArgumentException>(() => csc.IsSymbolAccessibleWithin(Av, Ac));
Assert.Throws <ArgumentException>(() => csc.IsSymbolAccessibleWithin(Ac, Av));
Assert.Throws <ArgumentException>(() => csc.IsSymbolAccessibleWithin(Ac, Ac, Av));
Assert.Throws <ArgumentException>(() => vbc.IsSymbolAccessibleWithin(Ac, Ac));
Assert.Throws <ArgumentException>(() => vbc.IsSymbolAccessibleWithin(Ac, Av));
Assert.Throws <ArgumentException>(() => vbc.IsSymbolAccessibleWithin(Av, Ac));
Assert.Throws <ArgumentException>(() => vbc.IsSymbolAccessibleWithin(Av, Av, Ac));
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// tree.GetRoot()
// .DescendantNodes()
// .OfType<MethodDeclarationSyntax>() //#2
// .Select(mds => //#3
// new
// {
// Name = mds.Identifier.ValueText,
// Switches = mds.Body
// .DescendantNodes()
// .OfType<SwitchStatementSyntax>()
// .Select(st =>
// new
// {
// SwitchStatement = st.ToFullString(),
// 52
////How many switch sections are there
////in the switch statement.
// Sections = st.Sections.Count
// })
//.OrderByDescending(st => st.Sections)//#4
// })
//.Dump("Switch statements per functions");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
protected void EachPositionBetweenStarsShouldProduceExpected(string code, ParserOutput expected, bool isCSharp, Profile profileOverload)
{
this.EnsureTwoStars(code);
var(startPos, endPos, actualCode) = this.GetCodeAndCursorRange(code);
var syntaxTree = isCSharp ? CSharpSyntaxTree.ParseText(actualCode)
: VisualBasicSyntaxTree.ParseText(actualCode);
Assert.IsNotNull(syntaxTree);
var semModel = isCSharp ? CSharpCompilation.Create(string.Empty).AddSyntaxTrees(syntaxTree).GetSemanticModel(syntaxTree, ignoreAccessibility: true)
: VisualBasicCompilation.Create(string.Empty).AddSyntaxTrees(syntaxTree).GetSemanticModel(syntaxTree, ignoreAccessibility: true);
var positionsTested = 0;
for (var pos = startPos; pos < endPos; pos++)
{
var indent = new TestVisualStudioAbstraction().XamlIndent;
var parser = isCSharp ? new CSharpParser(DefaultTestLogger.Create(), indent, profileOverload) as IDocumentParser
: new VisualBasicParser(DefaultTestLogger.Create(), indent, profileOverload);
var actual = parser.GetSingleItemOutput(syntaxTree.GetRoot(), semModel, pos);
Assert.AreEqual(expected.OutputType, actual.OutputType, $"Failure at {pos} ({startPos}-{endPos})");
Assert.AreEqual(expected.Name, actual.Name, $"Failure at {pos} ({startPos}-{endPos})");
StringAssert.AreEqual(expected.Output, actual.Output, $"Failure at {pos} ({startPos}-{endPos})");
positionsTested += 1;
}
this.TestContext.WriteLine($"{positionsTested} different positions tested.");
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// var classes = tree
// .GetRoot()
// .DescendantNodes()
// .OfType<ClassDeclarationSyntax>()//#1
// .Select(cds => new //#2
//{
// //Name of the class
// Name = cds.Identifier.ValueText,
// //Number of members of the class
// MemberCount = cds.Members.Count,
// //Number of public properties
// PublicPropertyCount = cds.Members
// .OfType<PropertyDeclarationSyntax>()
// .Count(pds => pds.Modifiers
// .Any(m => m.ValueText == "public"))
// })
// .Where(cds => cds.MemberCount == cds.PublicPropertyCount)//#3
// .Dump("Data Classes");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// tree.GetRoot()
// .DescendantNodes()
// .Where(t => t.Kind() == SyntaxKind.MethodDeclaration)
// .Cast<MethodDeclarationSyntax>()
// .Select(t =>
// new
// {
// Name = t.Identifier.ValueText, //#1
// Returns = t.Body.DescendantTokens()
// .Count(st => st.Kind() == SyntaxKind.ReturnKeyword)//#2
//})
// //Method should ideally have one return statement
// //That way it is easier to refactor them later.
// .Where(t => t.Returns > 1).Dump("Multiple return
// statements");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
//#1
// //There are couple of boxing calls in the provided code sample
// //These should have been avoided
// //x - Int
// //o -> object
//var objects =
//tree.GetRoot()
//.DescendantNodes().OfType<VariableDeclarationSyntax>()//#2
//.SelectMany(aes => aes.Variables.Select(v =>
//new //#3
//{
// Type = aes.GetFirstToken().ValueText,
// Name = v.Identifier.ValueText,
// Value = aes.GetLastToken().ValueText
//})
//);
//var defaulters = objects //#4
//.Where(aes => aes.Type == "object"
//&& objects.FirstOrDefault(d => d.Name == aes.Value
//&& d.Type != "object") != null)
//.Dump("Boxing calls");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
private static PortableExecutableReference GetInternalLibraryMetadataReference()
{
var syntaxTree = VisualBasicSyntaxTree.ParseText($@"Imports System.Runtime.CompilerServices
<Assembly: InternalsVisibleTo(""{TestProjectName}"")>
Namespace ExternalNamespace
Public Class InternalFoo
Friend Overridable Function Bar() As Integer
Return 1
End Function
End Class
End Namespace
");
var references = new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location) };
var compilationOptions = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
var compilation = VisualBasicCompilation.Create("Internal", new[] { syntaxTree }, references, compilationOptions);
using (var ms = new MemoryStream())
{
var result = compilation.Emit(ms);
if (result.Success == false)
{
var errors = result.Diagnostics.Where(diag => diag.IsWarningAsError || diag.Severity == DiagnosticSeverity.Error);
throw new InvalidOperationException($"Internal library compilation failed: {string.Join(",", errors)}");
}
ms.Seek(0, SeekOrigin.Begin);
return(MetadataReference.CreateFromStream(ms));
}
}
public static T Run <T>(string code)
{
var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var tree = VisualBasicSyntaxTree.ParseText(PlaceCodeInsideBlock(code));
var options = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
var comp = VisualBasicCompilation.Create("InMemoryAssembly")
.WithOptions(options)
.AddReferences(mscorlib)
.AddSyntaxTrees(tree);
using (var stream = new MemoryStream())
{
var response = comp.Emit(stream);
if (response.Success)
{
stream.Seek(0, SeekOrigin.Begin);
Assembly assembly = Assembly.Load(stream.ToArray());
Type type = assembly.GetType("Container");
return((T)type.InvokeMember("Execute", BindingFlags.Default | BindingFlags.InvokeMethod, null, null, null));
}
}
return(default(T));
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// tree.GetRoot()
// .DescendantNodes()
// .OfType<ClassDeclarationSyntax>()
// .Select(cds =>
// new
// {
// ClassName = cds.Identifier.ValueText,//#1
// Methods = cds.Members.OfType<MethodDeclarationSyntax>()
// .Select(mds => new {
// MethodName = mds.Identifier.ValueText//#2
// ,
// Parameters = mds.ParameterList.Parameters.Count//#3
//})
// }).Dump();
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// tree.GetRoot()
// .DescendantNodes()
// .OfType<ClassDeclarationSyntax>()//#2
// .Select(cds => new //#3
//{
// ClassName = cds.Identifier.ValueText,
// Properties = cds.Members
// .OfType<PropertyDeclarationSyntax>()
// .Select(pds => new //#4
//{
// PropertyName = pds.Identifier.ValueText,
// PropertyType = pds.Type.ToFullString()
// .Trim()
// })
// })
//.Where(cds => cds.Properties //#5
//.Any(p => p.PropertyType.Contains("[")))
//.Dump("Properties returning an array");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// tree.GetRoot()
// .DescendantNodes()
// .Where(t => t.Kind == SyntaxKind.ClassDeclaration)
// .Cast<ClassDeclarationSyntax>()
// .Select(cds =>
// new
// {
// ClassName = cds.Identifier.ValueText,//#1
//Methods = cds.Members.OfType < MethodDeclarationSy
// ntax > ()//#2
// .Select(mds => mds.Identifier.ValueText)
// })
// .Select(cds => new {
// ClassName = cds.ClassName,
// Overloads = cds.Methods
// .ToLookup(m => m)
// .ToDictionary(m => m.Key, m => m.Count())
// })//#3
// .Dump("Overloaded Methods");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
protected void EachPositionBetweenStarsShouldProduceExpected(string code, AnalyzerOutput expected, bool isCSharp, Profile profileOverload)
{
var startPos = code.IndexOf("*", StringComparison.Ordinal);
var endPos = code.LastIndexOf("*", StringComparison.Ordinal) - 1;
var syntaxTree = isCSharp ? CSharpSyntaxTree.ParseText(code.Replace("*", string.Empty))
: VisualBasicSyntaxTree.ParseText(code.Replace("*", string.Empty));
Assert.IsNotNull(syntaxTree);
var semModel = isCSharp ? CSharpCompilation.Create(string.Empty).AddSyntaxTrees(syntaxTree).GetSemanticModel(syntaxTree, ignoreAccessibility: true)
: VisualBasicCompilation.Create(string.Empty).AddSyntaxTrees(syntaxTree).GetSemanticModel(syntaxTree, ignoreAccessibility: true);
var positionsTested = 0;
for (var pos = startPos; pos < endPos; pos++)
{
var analyzer = isCSharp ? new CSharpAnalyzer(DefaultTestLogger.Create()) as IDocumentAnalyzer : new VisualBasicAnalyzer(DefaultTestLogger.Create());
var actual = analyzer.GetSingleItemOutput(syntaxTree.GetRoot(), semModel, pos, new TestVisualStudioAbstraction().XamlIndent, profileOverload);
Assert.AreEqual(expected.OutputType, actual.OutputType, $"Failure at {pos} ({startPos}-{endPos})");
Assert.AreEqual(expected.Name, actual.Name, $"Failure at {pos} ({startPos}-{endPos})");
StringAssert.AreEqual(expected.Output, actual.Output, $"Failure at {pos} ({startPos}-{endPos})");
positionsTested += 1;
}
this.TestContext.WriteLine($"{positionsTested} different positions tested.");
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// tree
// .GetRoot()
// .DescendantNodes()
// .OfType<ClassDeclarationSyntax>()//#1
// .Select(cds =>
//new
// {
// ClassName = cds.Identifier.ValueText,
// LocalClasses = cds.Members
//.OfType<ClassDeclarationSyntax>()
//.Select(m => m.Identifier.ValueText)
// }
// )
// .Where(cds => cds.LocalClasses.Count() >= 1)//#3
// .Dump("Local Classes");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public void CanDetectWhereAndWhenToInsertConstructorAndPageContentWhenConstructorExists()
{
var pageContent = "Public ReadOnly Property ViewModel As $viewmodelclass$"
+ Environment.NewLine + " Get"
+ Environment.NewLine + " Return New $viewmodelclass$"
+ Environment.NewLine + " End Get"
+ Environment.NewLine + "End Property";
var profile = TestProfile.CreateEmpty();
profile.ViewGeneration.XamlFileSuffix = "Page";
profile.ViewGeneration.ViewModelFileSuffix = "ViewModel";
profile.Datacontext.CodeBehindConstructorContent = "DataContext = ViewModel";
profile.Datacontext.CodeBehindPageContent = pageContent;
var logger = DefaultTestLogger.Create();
var fs = new TestFileSystem
{
FileText = @"Public NotInheritable Class TestPage
Inherits Page
Sub New()
InitializeComponent()
End Sub
End Class",
};
var synTree = VisualBasicSyntaxTree.ParseText(fs.FileText);
var vs = new TestVisualStudioAbstraction
{
ActiveDocumentFileName = "TestPage.xaml.vb",
ActiveDocumentText = fs.FileText,
SyntaxTree = synTree,
DocumentIsCSharp = false,
};
var sut = new SetDataContextCommandLogic(profile, logger, vs, fs);
var documentRoot = synTree.GetRoot();
var result = sut.GetCodeBehindContentToAdd("TestPage", "TestViewModel", "TestVmNamespace", documentRoot);
Assert.IsTrue(result[0].anythingToAdd);
Assert.AreEqual(5, result[0].lineNoToAddAfter);
StringAssert.AreEqual($"{Environment.NewLine}{Environment.NewLine}DataContext = ViewModel", result[0].contentToAdd);
var expectedContent = ""
+ Environment.NewLine + ""
+ Environment.NewLine + "Public ReadOnly Property ViewModel As TestViewModel"
+ Environment.NewLine + " Get"
+ Environment.NewLine + " Return New TestViewModel"
+ Environment.NewLine + " End Get"
+ Environment.NewLine + "End Property";
Assert.IsTrue(result[1].anythingToAdd);
Assert.AreEqual(8, result[1].lineNoToAddAfter);
StringAssert.AreEqual(expectedContent, result[1].contentToAdd);
}
public void CanBeReferencedByName()
{
var vbText = @"
Public Interface I
Property P(x As Integer)
End Interface
";
var vbcomp = VisualBasicCompilation.Create(
"Test",
new[] { VisualBasicSyntaxTree.ParseText(vbText) },
new[] { MscorlibRef_v4_0_30316_17626 },
new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var metaDataArray = vbcomp.EmitToArray();
var ref1 = new MetadataImageReference(metaDataArray, embedInteropTypes: true);
var text = @"class C : I {}";
var tree = Parse(text);
var comp = CreateCompilation(new [] { tree }, new [] { ref1 });
var t = comp.GetTypeByMetadataName("I");
Assert.Empty(t.GetMembersUnordered().Where(x => x.Kind == SymbolKind.Method && !x.CanBeReferencedByName));
Assert.False(t.GetMembersUnordered().Where(x => x.Kind == SymbolKind.Property).First().CanBeReferencedByName); //there's only one.
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// var classAndMembers = tree.GetRoot()
// .DescendantNodes()
// .Where(t => t.Kind() == SyntaxKind.ClassDeclaration)
// .Cast<ClassDeclarationSyntax>()//#1
// .Select(cds =>
// new {
// ClassName = cds.Identifier.ValueText,//#2
// Size = cds.Members.Count//#3
//});
// var averageLength =
// classAndMembers
// .Select(classDetails => classDetails.Size)
// .Average();//#4
// classAndMembers
// .Where(am => am.Size > averageLength)//#5
// .Dump("Large Class");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
/// <summary>
/// Build script
/// </summary>
/// <param name="filenames">File names</param>
/// <param name="references">References</param>
/// <param name="releaseMode">Release mode (default=true)</param>
/// <returns>Assembly</returns>
public static Assembly CompileVBFile(string[] filenames, string[] references, bool releaseMode = true)
{
var tree = filenames.Select(u => VisualBasicSyntaxTree.ParseText(File.ReadAllText(u))).ToArray();
var op = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optimizationLevel: releaseMode ? OptimizationLevel.Release : OptimizationLevel.Debug);
return(Assembly.Create(VisualBasicCompilation.Create("SmartContract", tree, CreateReferences(references), op)));
}
private static SyntaxTree ParseFile(string sourceFilePath)
{
// Read the source file content
SourceText fileContent = null;
using (var stream = new FileStream(sourceFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, bufferSize: 1, options: FileOptions.None))
{
fileContent = SourceText.From(stream);
}
// Build a SyntaxTree to return
string extension = Path.GetExtension(sourceFilePath).ToLowerInvariant();
switch (extension)
{
case ".cs":
return(CSharpSyntaxTree.ParseText(fileContent, path: sourceFilePath));
case ".vb":
return(VisualBasicSyntaxTree.ParseText(fileContent, path: sourceFilePath));
default:
throw new NotImplementedException(String.Format("Unable to build definition finder for unknown file extension of file '{0}'", sourceFilePath));
}
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// var result = tree.GetRoot()
// .DescendantNodes()
// .OfType<MethodDeclarationSyntax>()//#1
// .Where(thisMethod => //#2
// //This method is not an event declaration
// !thisMethod.IsEventDeclaration()
// && thisMethod.TakesOrReturnsObject())
// .Select(thisMethod =>
// thisMethod.Identifier.ValueText); //#3
// if (result.Count() > 0)
// {
// result.Dump(@"Methods that aren't event handlers but takes or
//returns objects");
// }
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
//tree.GetRoot()
//.DescendantNodes()
//.OfType<BracketedArgumentListSyntax>()
//.Select(bals =>
//new
//{
// Method = bals.Ancestors()
//.OfType<MethodDeclarationSyntax>()
//.First()
//.Identifier.ValueText,
// Indices = bals.Arguments
//.Select(a => a.GetText()
//.Container
//.CurrentText
//.ToString())
//})
////Find defaulter methods that use magic indices
//.Where(bals =>
//bals.Indices
//.Any(i => Regex.Match(i, "[0-9]+").Success))
//.Dump("Methods using magic indices");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public Compilation Compile(string assemblyInfoText)
{
return(VisualBasicCompilation.Create("Fake.dll")
.WithOptions(new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary, rootNamespace: "Fake"))
.AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
.AddSyntaxTrees(VisualBasicSyntaxTree.ParseText(assemblyInfoText)));
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// tree.GetRoot()
// .DescendantNodes()
// .OfType<FieldDeclarationSyntax>()//#2
// .Where(vds => vds.Modifiers
// .Any(m => m.ValueText == "volatile"))//#3
// .Select(vds => new //#4
//{
// ClassName = vds.Ancestors()
// .OfType<ClassDeclarationSyntax>()
// .First()?.Identifier.ValueText,
// VolatileDeclaration = vds.ToFullString()
// })
// .Dump();
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public void Parse(string sourceCode)
{
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
var node = tree.GetRoot();
Visit(node);
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// //The recommended value is 64;
// //But for deomonstration purpose it is changed to 4
//const int MAX_LOCALS_ALLOWED = 4; //#2
//tree.GetRoot()
//.DescendantNodes()
//.OfType<MethodDeclarationSyntax>() //#3
//.Where(mds =>
//mds.Body.Statements
//.OfType<LocalDeclarationStatementSyntax>()
//.Count() >= MAX_LOCALS_ALLOWED) //#4
//.Select(mds => mds.Identifier.ValueText)//#5
//.Dump("Methods with many local variable declarations");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public async Task FileJustContainsComments()
{
var profile = this.GetDefaultTestProfile();
profile.ViewGeneration.AllInSameProject = true;
profile.ViewGeneration.ViewModelDirectoryName = "Files";
profile.ViewGeneration.ViewModelFileSuffix = "ViewModel";
profile.ViewGeneration.XamlFileDirectoryName = "Files";
profile.ViewGeneration.XamlFileSuffix = "Page";
var fs = new TestFileSystem
{
FileExistsResponse = false,
FileText = @" ' Just comments in this file",
};
var synTree = VisualBasicSyntaxTree.ParseText(fs.FileText);
var semModel = VisualBasicCompilation.Create(string.Empty).AddSyntaxTrees(synTree).GetSemanticModel(synTree, ignoreAccessibility: true);
var vsa = new TestVisualStudioAbstraction
{
SyntaxTree = synTree,
SemanticModel = semModel,
ActiveProject = new ProjectWrapper()
{
Name = "App", FileName = @"C:\Test\App\App.vbproj"
},
};
var sut = new CreateViewCommandLogic(DefaultTestLogger.Create(), vsa, fs, profile);
await sut.ExecuteAsync(@"C:\Test\App\Files\TestViewModel.vb");
Assert.IsFalse(sut.CreateView);
}
public override void Process(string path, string basePath, LocalizableStringCollection strings)
{
/* VB */
var codeMetadataProvider = new CodeMetadataProvider(basePath);
var csharpWalker = new ExtractingCodeWalker(
new IStringExtractor <SyntaxNode>[]
{
new SingularStringExtractor(codeMetadataProvider),
new PluralStringExtractor(codeMetadataProvider),
new DataAnnotationStringExtractor(codeMetadataProvider)
}, strings);
foreach (var file in Directory.EnumerateFiles(path, "*.vb", SearchOption.AllDirectories).OrderBy(file => file))
{
if (Path.GetFileName(file).EndsWith(".cshtml.g.cs"))
{
continue;
}
using (var stream = File.OpenRead(file))
{
using (var reader = new StreamReader(stream))
{
var syntaxTree = VisualBasicSyntaxTree.ParseText(reader.ReadToEnd(), path: file);
csharpWalker.Visit(syntaxTree.GetRoot());
}
}
}
base.Process(path, basePath, strings);
}
private static Compilation CreateCompilation(string source, string language, DiagnosticAnalyzer[] analyzers, string rootNamespace)
{
string fileName = language == LanguageNames.CSharp ? "Test.cs" : "Test.vb";
string projectName = "TestProject";
var syntaxTree = language == LanguageNames.CSharp ?
CSharpSyntaxTree.ParseText(source, path: fileName) :
VisualBasicSyntaxTree.ParseText(source, path: fileName);
if (language == LanguageNames.CSharp)
{
return(CSharpCompilation.Create(
projectName,
syntaxTrees: new[] { syntaxTree },
references: new[] { TestBase.MscorlibRef }));
}
else
{
return(VisualBasicCompilation.Create(
projectName,
syntaxTrees: new[] { syntaxTree },
references: new[] { TestBase.MscorlibRef },
options: new VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
rootNamespace: rootNamespace)));
}
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// var abstractTypes =
// tree.GetRoot()
// .DescendantNodes()
// .OfType<ClassDeclarationSyntax>()
// .Where(cds => cds.Modifiers
// .Any(m => m.ValueText == "abstract"))//#1
// .Select(cds => new //#2
//{
// ClassName = cds.Identifier.ValueText,
// PublicConstructors =
// cds.Members
// .OfType<ConstructorDeclarationSyntax>()
// .Any(c => c.Modifiers
// .Any(m => m.ValueText == "public"))
// })
// .Where(cds => cds.PublicConstructors)//#3
// .Dump("AbstractTypesShouldNotHaveConstructors Violators");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
public static StringBuilder Check(string sourceCode)
{
StringBuilder sb = new StringBuilder();
var tree = VisualBasicSyntaxTree.ParseText(sourceCode);
// tree.GetRoot()
// .DescendantNodes()
// .Where(t => loopTypes.Any(l => t.Kind() == l))//#3
// .Select(t => new //#4
//{
// Method = t.Ancestors()
// .OfType<MethodDeclarationSyntax>()
// .First()
// .Identifier.ValueText,
// Nesting = 1 + t.Ancestors()
// .Count(z => loopTypes
// .Any(l => z.Kind() == l))
// })
// .ToLookup(t => t.Method)
// //#5
// .ToDictionary(t => t.Key,
// t => t.Select(m => m.Nesting).Max())
// .Select(t => new { Method = t.Key, Nesting = t.Value })
// //Find only if blocks that are deeper than 3 levels.
// .Where(t => t.Nesting >= 3)//#6
// .Dump("Deeply nested if-statements");
sb.AppendLine(MethodBase.GetCurrentMethod().DeclaringType
+ "." + MethodBase.GetCurrentMethod().Name
+ " Not Implemented Yet");
return(sb);
}
private static CompilationUnit[] ExtractCompilationUnits(Project project)
{
using (var logger = LogManager.GetLogger("Test execution"))
{
var csharpTrees = new List <SyntaxTree>(project.CompileItems.Length);
var visualBasicTrees = new List <SyntaxTree>(project.CompileItems.Length);
foreach (var item in project.CompileItems)
{
if (!File.Exists(item))
{
logger.Error($"File {item} doesn't exist");
continue;
}
var code = File.ReadAllText(item);
if (Path.GetExtension(item).EqualsNoCase(".vb"))
{
visualBasicTrees.Add(VisualBasicSyntaxTree.ParseText(code, VisualBasicParseOptions.Default, item));
}
else
{
// NOTE: currently is assumed that all this files is C#
// TODO: fix it in the future
csharpTrees.Add(CSharpSyntaxTree.ParseText(code, CSharpParseOptions.Default, item));
}
}
var references = new List <MetadataReference>(project.AssemblyReferences.Length + project.ProjectReferences.Length);
foreach (var item in project.AssemblyReferences)
{
references.Add(MetadataReference.CreateFromFile(item));
}
foreach (var item in project.ProjectReferences)
{
foreach (var unit in ExtractCompilationUnits(item))
{
references.Add(unit.Compilation.ToMetadataReference());
}
}
var visualBasicOptions = new VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary,
rootNamespace: project.RootNamespace,
globalImports: project.Imports.Select(GlobalImport.Parse),
optionCompareText: project.OptionCompare,
optionExplicit: project.OptionExplicit,
optionInfer: project.OptionInfer,
optionStrict: project.OptionStrict ? OptionStrict.On : OptionStrict.Off);
return(new CompilationUnit[]
{
CSharpCompilation.Create($"{project.ProjectName}_{LanguageNames.CSharp}")
.AddSyntaxTrees(csharpTrees)
.AddReferences(references),
VisualBasicCompilation.Create($"{project.ProjectName}_{LanguageNames.VisualBasic}", options: visualBasicOptions)
.AddSyntaxTrees(visualBasicTrees)
.AddReferences(references)
});
}
}