From 62451c4b87e5c01b1915129fd2fc021231cdede2 Mon Sep 17 00:00:00 2001
From: Andreas Weizel
Date: Tue, 16 Aug 2016 19:01:02 +0200
Subject: [PATCH 001/236] Made some async delegates registered as analyzer
callbacks synchronous to solve issue #251.
---
.../CSharp/Diagnostics/Custom/XmlDocAnalyzer.cs | 4 ++--
.../Synced/CodeQuality/FunctionNeverReturnsAnalyzer.cs | 4 ++--
.../CodeQuality/MemberHidesStaticFromOuterClassAnalyzer.cs | 4 ++--
.../StaticFieldOrAutoPropertyInGenericTypeAnalyzer.cs | 4 ++--
.../FieldCanBeMadeReadOnlyAnalyzer.cs | 4 ++--
.../RedundanciesInCode/RedundantUnsafeContextAnalyzer.cs | 4 ++--
.../RedundanciesInDeclaration/UnusedParameterAnalyzer.cs | 4 ++--
7 files changed, 14 insertions(+), 14 deletions(-)
diff --git a/RefactoringEssentials/CSharp/Diagnostics/Custom/XmlDocAnalyzer.cs b/RefactoringEssentials/CSharp/Diagnostics/Custom/XmlDocAnalyzer.cs
index 0078a79e..bfda5c88 100644
--- a/RefactoringEssentials/CSharp/Diagnostics/Custom/XmlDocAnalyzer.cs
+++ b/RefactoringEssentials/CSharp/Diagnostics/Custom/XmlDocAnalyzer.cs
@@ -34,14 +34,14 @@ public override void Initialize(AnalysisContext context)
context.RegisterCompilationStartAction(compilationContext =>
{
var compilation = compilationContext.Compilation;
- compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext ctx)
+ compilationContext.RegisterSyntaxTreeAction(delegate (SyntaxTreeAnalysisContext ctx)
{
try
{
if (!compilation.SyntaxTrees.Contains(ctx.Tree))
return;
var semanticModel = compilation.GetSemanticModel(ctx.Tree);
- var root = await ctx.Tree.GetRootAsync(ctx.CancellationToken).ConfigureAwait(false);
+ var root = ctx.Tree.GetRoot(ctx.CancellationToken);
var model = compilationContext.Compilation.GetSemanticModel(ctx.Tree);
new GatherVisitor(ctx, semanticModel).Visit(root);
}
diff --git a/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/FunctionNeverReturnsAnalyzer.cs b/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/FunctionNeverReturnsAnalyzer.cs
index 07eef234..0be090fe 100644
--- a/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/FunctionNeverReturnsAnalyzer.cs
+++ b/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/FunctionNeverReturnsAnalyzer.cs
@@ -33,14 +33,14 @@ public override void Initialize(AnalysisContext context)
context.RegisterCompilationStartAction(compilationContext =>
{
var compilation = compilationContext.Compilation;
- compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext ctx)
+ compilationContext.RegisterSyntaxTreeAction(delegate (SyntaxTreeAnalysisContext ctx)
{
try
{
if (!compilation.SyntaxTrees.Contains(ctx.Tree))
return;
var semanticModel = compilation.GetSemanticModel(ctx.Tree);
- var root = await ctx.Tree.GetRootAsync(ctx.CancellationToken).ConfigureAwait(false);
+ var root = ctx.Tree.GetRoot(ctx.CancellationToken);
var model = compilationContext.Compilation.GetSemanticModel(ctx.Tree);
new GatherVisitor(ctx, semanticModel).Visit(root);
}
diff --git a/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/MemberHidesStaticFromOuterClassAnalyzer.cs b/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/MemberHidesStaticFromOuterClassAnalyzer.cs
index 7c408f24..eaebfb7e 100644
--- a/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/MemberHidesStaticFromOuterClassAnalyzer.cs
+++ b/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/MemberHidesStaticFromOuterClassAnalyzer.cs
@@ -30,14 +30,14 @@ public override void Initialize(AnalysisContext context)
context.RegisterCompilationStartAction(compilationContext =>
{
var compilation = compilationContext.Compilation;
- compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext ctx)
+ compilationContext.RegisterSyntaxTreeAction(delegate (SyntaxTreeAnalysisContext ctx)
{
try
{
if (!compilation.SyntaxTrees.Contains(ctx.Tree))
return;
var semanticModel = compilation.GetSemanticModel(ctx.Tree);
- var root = await ctx.Tree.GetRootAsync(ctx.CancellationToken).ConfigureAwait(false);
+ var root = ctx.Tree.GetRoot(ctx.CancellationToken);
var model = compilationContext.Compilation.GetSemanticModel(ctx.Tree);
new GatherVisitor(ctx, semanticModel).Visit(root);
}
diff --git a/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/StaticFieldOrAutoPropertyInGenericTypeAnalyzer.cs b/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/StaticFieldOrAutoPropertyInGenericTypeAnalyzer.cs
index 3b116c5a..dc4b5351 100644
--- a/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/StaticFieldOrAutoPropertyInGenericTypeAnalyzer.cs
+++ b/RefactoringEssentials/CSharp/Diagnostics/Synced/CodeQuality/StaticFieldOrAutoPropertyInGenericTypeAnalyzer.cs
@@ -31,14 +31,14 @@ public override void Initialize(AnalysisContext context)
context.RegisterCompilationStartAction(compilationContext =>
{
var compilation = compilationContext.Compilation;
- compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext ctx)
+ compilationContext.RegisterSyntaxTreeAction(delegate (SyntaxTreeAnalysisContext ctx)
{
try
{
if (!compilation.SyntaxTrees.Contains(ctx.Tree))
return;
var semanticModel = compilation.GetSemanticModel(ctx.Tree);
- var root = await ctx.Tree.GetRootAsync(ctx.CancellationToken).ConfigureAwait(false);
+ var root = ctx.Tree.GetRoot(ctx.CancellationToken);
var model = compilationContext.Compilation.GetSemanticModel(ctx.Tree);
new GatherVisitor(ctx, semanticModel).Visit(root);
}
diff --git a/RefactoringEssentials/CSharp/Diagnostics/Synced/PracticesAndImprovements/FieldCanBeMadeReadOnlyAnalyzer.cs b/RefactoringEssentials/CSharp/Diagnostics/Synced/PracticesAndImprovements/FieldCanBeMadeReadOnlyAnalyzer.cs
index dbad32b4..f1ab8c92 100644
--- a/RefactoringEssentials/CSharp/Diagnostics/Synced/PracticesAndImprovements/FieldCanBeMadeReadOnlyAnalyzer.cs
+++ b/RefactoringEssentials/CSharp/Diagnostics/Synced/PracticesAndImprovements/FieldCanBeMadeReadOnlyAnalyzer.cs
@@ -34,14 +34,14 @@ public override void Initialize(AnalysisContext context)
void Analyze(CompilationStartAnalysisContext compilationContext)
{
var compilation = compilationContext.Compilation;
- compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext context)
+ compilationContext.RegisterSyntaxTreeAction(delegate (SyntaxTreeAnalysisContext context)
{
try
{
if (!compilation.SyntaxTrees.Contains(context.Tree))
return;
var semanticModel = compilation.GetSemanticModel(context.Tree);
- var root = await context.Tree.GetRootAsync(context.CancellationToken).ConfigureAwait(false);
+ var root = context.Tree.GetRoot(context.CancellationToken);
var model = compilationContext.Compilation.GetSemanticModel(context.Tree);
foreach (var type in root.DescendantNodesAndSelf(SkipMembers).OfType())
{
diff --git a/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantUnsafeContextAnalyzer.cs b/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantUnsafeContextAnalyzer.cs
index c2724427..c7e7e0ab 100644
--- a/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantUnsafeContextAnalyzer.cs
+++ b/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantUnsafeContextAnalyzer.cs
@@ -33,14 +33,14 @@ public override void Initialize(AnalysisContext context)
context.RegisterCompilationStartAction(compilationContext =>
{
var compilation = compilationContext.Compilation;
- compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext ctx)
+ compilationContext.RegisterSyntaxTreeAction(delegate (SyntaxTreeAnalysisContext ctx)
{
try
{
if (!compilation.SyntaxTrees.Contains(ctx.Tree))
return;
var semanticModel = compilation.GetSemanticModel(ctx.Tree);
- var root = await ctx.Tree.GetRootAsync(ctx.CancellationToken).ConfigureAwait(false);
+ var root = ctx.Tree.GetRoot(ctx.CancellationToken);
var model = compilationContext.Compilation.GetSemanticModel(ctx.Tree);
if (model.IsFromGeneratedCode(compilationContext.CancellationToken))
return;
diff --git a/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInDeclaration/UnusedParameterAnalyzer.cs b/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInDeclaration/UnusedParameterAnalyzer.cs
index e8f2f463..ac421c3f 100644
--- a/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInDeclaration/UnusedParameterAnalyzer.cs
+++ b/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInDeclaration/UnusedParameterAnalyzer.cs
@@ -35,14 +35,14 @@ public override void Initialize(AnalysisContext context)
void Analyze(CompilationStartAnalysisContext compilationContext)
{
var compilation = compilationContext.Compilation;
- compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext context)
+ compilationContext.RegisterSyntaxTreeAction(delegate (SyntaxTreeAnalysisContext context)
{
try
{
if (!compilation.SyntaxTrees.Contains(context.Tree))
return;
var semanticModel = compilation.GetSemanticModel(context.Tree);
- var root = await context.Tree.GetRootAsync(context.CancellationToken).ConfigureAwait(false);
+ var root = context.Tree.GetRoot(context.CancellationToken);
var model = compilationContext.Compilation.GetSemanticModel(context.Tree);
if (model.IsFromGeneratedCode(compilationContext.CancellationToken))
return;
From a83e7b93434fbb76631851f20ad34770097772f7 Mon Sep 17 00:00:00 2001
From: Andreas Weizel
Date: Thu, 18 Aug 2016 19:41:59 +0200
Subject: [PATCH 002/236] Fixed #248: Removing ToString is too relaxed
---
.../RedundantToStringCallAnalyzer.cs | 24 ++
.../Diagnostics/RedundantToStringCallTests.cs | 331 ++++++++++--------
2 files changed, 210 insertions(+), 145 deletions(-)
diff --git a/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantToStringCallAnalyzer.cs b/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantToStringCallAnalyzer.cs
index 3b564a01..5c3c24f5 100644
--- a/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantToStringCallAnalyzer.cs
+++ b/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantToStringCallAnalyzer.cs
@@ -149,9 +149,12 @@ void CheckInvocationInAutoCallContext(InvocationExpressionSyntax invocationExpre
{
return;
}
+ if (!OverridesObjectToStringMethod(resolveResult))
+ return;
var type = nodeContext.SemanticModel.GetTypeInfo(memberExpression.Expression).Type;
if ((type != null) && type.IsValueType)
return;
+
AddRedundantToStringIssue(memberExpression, invocationExpression);
}
@@ -167,6 +170,25 @@ void AddRedundantToStringIssue(MemberAccessExpressionSyntax memberExpression, In
#region Invocation expression
+ static bool OverridesObjectToStringMethod(ISymbol toStringSymbol)
+ {
+ ISymbol currentSymbol = toStringSymbol;
+ while (currentSymbol != null)
+ {
+ var currentMethodSymbol = currentSymbol as IMethodSymbol;
+ if ((currentMethodSymbol != null)
+ && (currentSymbol.ContainingType != null)
+ && (currentSymbol.ContainingType.SpecialType == SpecialType.System_Object))
+ {
+ // Found object.ToString()
+ return true;
+ }
+ currentSymbol = currentSymbol.OverriddenMember();
+ }
+
+ return false;
+ }
+
static void CheckTargetedObject(SyntaxNodeAnalysisContext nodeContext, InvocationExpressionSyntax invocationExpression, ISymbol member)
{
var memberExpression = invocationExpression.Expression as MemberAccessExpressionSyntax;
@@ -233,6 +255,8 @@ static void CheckInvocationInAutoCallContext(SyntaxNodeAnalysisContext nodeConte
{
return;
}
+ if (!OverridesObjectToStringMethod(resolveResult))
+ return;
var type = nodeContext.SemanticModel.GetTypeInfo(memberExpression.Expression).Type;
if ((type != null) && type.IsValueType)
return;
diff --git a/Tests/CSharp/Diagnostics/RedundantToStringCallTests.cs b/Tests/CSharp/Diagnostics/RedundantToStringCallTests.cs
index 8ba8784d..469acd55 100644
--- a/Tests/CSharp/Diagnostics/RedundantToStringCallTests.cs
+++ b/Tests/CSharp/Diagnostics/RedundantToStringCallTests.cs
@@ -12,17 +12,17 @@ public void ConcatenationOperator()
Analyze(@"
class Foo
{
- void Bar (object i)
- {
- string s = """" + i$.ToString()$ + """" + i$.ToString()$;
- }
+ void Bar (object i)
+ {
+ string s = """" + i$.ToString()$ + """" + i$.ToString()$;
+ }
}", @"
class Foo
{
- void Bar (object i)
- {
- string s = """" + i + """" + i.ToString();
- }
+ void Bar (object i)
+ {
+ string s = """" + i + """" + i.ToString();
+ }
}", 0);
}
@@ -32,10 +32,10 @@ public void TestValueTypes()
Analyze(@"
class Foo
{
- void Bar (int i)
- {
- string s = """" + i.ToString() + """" + i.ToString();
- }
+ void Bar (int i)
+ {
+ string s = """" + i.ToString() + """" + i.ToString();
+ }
}");
}
@@ -46,10 +46,10 @@ public void ConcatenationOperatorWithToStringAsOnlyString()
Analyze(@"
class Foo
{
- void Bar (int i)
- {
- string s = i.ToString() + i + i + i + 1.3;
- }
+ void Bar (int i)
+ {
+ string s = i.ToString() + i + i + i + 1.3;
+ }
}");
}
@@ -59,10 +59,10 @@ public void IgnoresCallsToIFormattableToString()
Analyze(@"
class Foo
{
- void Bar (System.DateTime dt)
- {
- string s = dt.ToString("""", CultureInfo.InvariantCulture) + string.Empty;
- }
+ void Bar (System.DateTime dt)
+ {
+ string s = dt.ToString("""", CultureInfo.InvariantCulture) + string.Empty;
+ }
}");
}
@@ -72,19 +72,19 @@ public void StringTarget()
Analyze(@"
class Foo
{
- void Bar (string str)
- {
- string s = str$.ToString()$;
- string inOperator = """" + str$.ToString()$;
- }
+ void Bar (string str)
+ {
+ string s = str$.ToString()$;
+ string inOperator = """" + str$.ToString()$;
+ }
}", @"
class Foo
{
- void Bar (string str)
- {
- string s = str;
- string inOperator = """" + str;
- }
+ void Bar (string str)
+ {
+ string s = str;
+ string inOperator = """" + str;
+ }
}");
}
@@ -94,17 +94,17 @@ public void FormatStringTests()
Analyze(@"
class Foo
{
- void Bar (object i)
- {
- string s = string.Format(""{0}"", i$.ToString()$);
- }
+ void Bar (object i)
+ {
+ string s = string.Format(""{0}"", i$.ToString()$);
+ }
}", @"
class Foo
{
- void Bar (object i)
- {
- string s = string.Format(""{0}"", i);
- }
+ void Bar (object i)
+ {
+ string s = string.Format(""{0}"", i);
+ }
}");
}
@@ -114,19 +114,19 @@ public void HandlesNonLiteralFormatParameter()
Analyze(@"
class Foo
{
- void Bar (object i)
- {
- string format = ""{0}"";
- string s = string.Format(format, i$.ToString()$);
- }
+ void Bar (object i)
+ {
+ string format = ""{0}"";
+ string s = string.Format(format, i$.ToString()$);
+ }
}", @"
class Foo
{
- void Bar (object i)
- {
- string format = ""{0}"";
- string s = string.Format(format, i);
- }
+ void Bar (object i)
+ {
+ string format = ""{0}"";
+ string s = string.Format(format, i);
+ }
}");
}
@@ -137,31 +137,31 @@ public void FormatStringWithNonObjectParameterTests()
Analyze(@"
class Foo
{
- void Bar (object i)
- {
- string s = FakeFormat(""{0} {1}"", i.ToString(), i$.ToString()$);
- }
-
- void FakeFormat(string format, string arg0, object arg1)
- {
- }
- void FakeFormat(string format, params object[] arg1)
- {
- }
+ void Bar (object i)
+ {
+ string s = FakeFormat(""{0} {1}"", i.ToString(), i$.ToString()$);
+ }
+
+ void FakeFormat(string format, string arg0, object arg1)
+ {
+ }
+ void FakeFormat(string format, params object[] arg1)
+ {
+ }
}", @"
class Foo
{
- void Bar (object i)
- {
- string s = FakeFormat(""{0} {1}"", i.ToString (), i);
- }
-
- void FakeFormat(string format, string arg0, object arg1)
- {
- }
- void FakeFormat(string format, params object[] arg1)
- {
- }
+ void Bar (object i)
+ {
+ string s = FakeFormat(""{0} {1}"", i.ToString (), i);
+ }
+
+ void FakeFormat(string format, string arg0, object arg1)
+ {
+ }
+ void FakeFormat(string format, params object[] arg1)
+ {
+ }
}");
}
@@ -172,25 +172,25 @@ public void FormatMethodWithObjectParamsArray()
Analyze(@"
class Foo
{
- void Bar (object i)
- {
- string s = FakeFormat(""{0} {1}"", i$.ToString()$, i$.ToString()$);
- }
+ void Bar (object i)
+ {
+ string s = FakeFormat(""{0} {1}"", i$.ToString()$, i$.ToString()$);
+ }
- void FakeFormat(string format, params object[] args)
- {
- }
+ void FakeFormat(string format, params object[] args)
+ {
+ }
}", @"
class Foo
{
- void Bar (object i)
- {
- string s = FakeFormat(""{0} {1}"", i, i);
- }
+ void Bar (object i)
+ {
+ string s = FakeFormat(""{0} {1}"", i, i);
+ }
- void FakeFormat(string format, params object[] args)
- {
- }
+ void FakeFormat(string format, params object[] args)
+ {
+ }
}");
}
@@ -200,21 +200,21 @@ public void DetectsBlacklistedCalls()
Analyze(@"
class Foo
{
- void Bar (object i)
- {
- var w = new System.IO.StringWriter ();
- w.Write(i$.ToString()$);
- w.WriteLine(i$.ToString()$);
- }
+ void Bar (object i)
+ {
+ var w = new System.IO.StringWriter ();
+ w.Write(i$.ToString()$);
+ w.WriteLine(i$.ToString()$);
+ }
}", @"
class Foo
{
- void Bar (object i)
- {
- var w = new System.IO.StringWriter ();
- w.Write(i);
- w.WriteLine(i);
- }
+ void Bar (object i)
+ {
+ var w = new System.IO.StringWriter ();
+ w.Write(i);
+ w.WriteLine(i);
+ }
}");
}
@@ -224,10 +224,10 @@ public void ConcatenationOperator2()
Analyze(@"
class Foo
{
- void Bar (int i)
- {
- string s = """" + i.ToString() + """" + i.ToString();
- }
+ void Bar (int i)
+ {
+ string s = """" + i.ToString() + """" + i.ToString();
+ }
}");
}
@@ -237,10 +237,10 @@ public void TestReferenceTypes2()
Analyze(@"
class Foo
{
- void Bar (object i)
- {
- string s = """" + i$.ToString()$ + """" + i$.ToString()$;
- }
+ void Bar (object i)
+ {
+ string s = """" + i$.ToString()$ + """" + i$.ToString()$;
+ }
}");
}
@@ -250,10 +250,10 @@ public void ConcatenationOperatorWithToStringAsOnlyString2()
Analyze(@"
class Foo
{
- void Bar (int i)
- {
- string s = i.ToString() + i + i + i + 1.3;
- }
+ void Bar (int i)
+ {
+ string s = i.ToString() + i + i + i + 1.3;
+ }
}");
}
@@ -263,10 +263,10 @@ public void IgnoresCallsToIFormattableToString2()
Analyze(@"
class Foo
{
- void Bar (System.DateTime dt)
- {
- string s = dt.ToString("""", CultureInfo.InvariantCulture) + string.Empty;
- }
+ void Bar (System.DateTime dt)
+ {
+ string s = dt.ToString("""", CultureInfo.InvariantCulture) + string.Empty;
+ }
}");
}
@@ -276,10 +276,10 @@ public void FormatStringTests2()
Analyze(@"
class Foo
{
- void Bar (int i)
- {
- string s = string.Format(""{0}"", i.ToString());
- }
+ void Bar (int i)
+ {
+ string s = string.Format(""{0}"", i.ToString());
+ }
}");
}
@@ -289,11 +289,11 @@ public void HandlesNonLiteralFormatParameter2()
Analyze(@"
class Foo
{
- void Bar (int i)
- {
- string format = ""{0}"";
- string s = string.Format(format, i.ToString());
- }
+ void Bar (int i)
+ {
+ string format = ""{0}"";
+ string s = string.Format(format, i.ToString());
+ }
}");
}
@@ -304,17 +304,17 @@ public void FormatStringWithNonObjectParameterTests2()
Analyze(@"
class Foo
{
- void Bar (int i)
- {
- string s = FakeFormat(""{0} {1}"", i.ToString(), i.ToString());
- }
-
- void FakeFormat(string format, string arg0, object arg1)
- {
- }
- void FakeFormat(string format, params object[] args)
- {
- }
+ void Bar (int i)
+ {
+ string s = FakeFormat(""{0} {1}"", i.ToString(), i.ToString());
+ }
+
+ void FakeFormat(string format, string arg0, object arg1)
+ {
+ }
+ void FakeFormat(string format, params object[] args)
+ {
+ }
}");
}
@@ -325,14 +325,14 @@ public void FormatMethodWithObjectParamsArray2()
Analyze(@"
class Foo
{
- void Bar (int i)
- {
- string s = FakeFormat(""{0} {1}"", i.ToString(), i.ToString());
- }
+ void Bar (int i)
+ {
+ string s = FakeFormat(""{0} {1}"", i.ToString(), i.ToString());
+ }
- void FakeFormat(string format, params object[] args)
- {
- }
+ void FakeFormat(string format, params object[] args)
+ {
+ }
}");
}
@@ -342,12 +342,12 @@ public void DetectsBlacklistedCalls2()
Analyze(@"
class Foo
{
- void Bar (int i)
- {
- var w = new System.IO.StringWriter ();
- w.Write(i.ToString());
- w.WriteLine(i.ToString());
- }
+ void Bar (int i)
+ {
+ var w = new System.IO.StringWriter ();
+ w.Write(i.ToString());
+ w.WriteLine(i.ToString());
+ }
}");
}
@@ -383,5 +383,46 @@ void Foo (string s) {}
}");
}
+ [Test]
+ public void TestIgnoresShadowedToStringInConcatenation()
+ {
+ Analyze(@"
+class ClassShadowingToString
+{
+ public new string ToString()
+ {
+ return ""ANYTHING"";
+ }
+}
+
+class Foo
+{
+ void Bar (ClassShadowingToString v)
+ {
+ string s = """" + v.ToString();
+ }
+}");
+ }
+
+ [Test]
+ public void TestIgnoresShadowedToStringInFormatParameter()
+ {
+ Analyze(@"
+class ClassShadowingToString
+{
+ public new string ToString()
+ {
+ return ""ANYTHING"";
+ }
+}
+
+class Foo
+{
+ void Bar (ClassShadowingToString v)
+ {
+ string s = string.Format(""{0}"", v.ToString());
+ }
+}");
+ }
}
}
\ No newline at end of file
From 196f8f27da706423e0e0f345023f0d909ddc82a1 Mon Sep 17 00:00:00 2001
From: Andreas Weizel
Date: Fri, 19 Aug 2016 16:10:49 +0200
Subject: [PATCH 003/236] Fixed #240: RefactoringEssentials.pdb is not included
in .vsix
---
Vsix/Vsix.csproj | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/Vsix/Vsix.csproj b/Vsix/Vsix.csproj
index fd2817b4..245f8058 100644
--- a/Vsix/Vsix.csproj
+++ b/Vsix/Vsix.csproj
@@ -40,7 +40,7 @@
truetruetrue
- false
+ trueRoslyn
@@ -102,6 +102,7 @@
{c465a5dc-ad28-49a2-89c0-f81838814a7e}RefactoringEssentialsDebugSymbolsProjectOutputGroup
+ DebugSymbolsProjectOutputGroup
From d4beb3e775c032dcf9a576ac2de26bd8155a827f Mon Sep 17 00:00:00 2001
From: Andreas Weizel
Date: Wed, 14 Sep 2016 00:21:15 +0200
Subject: [PATCH 004/236] Fixed #255: Wrong usafe redundancy proposal
---
.../RedundantUnsafeContextAnalyzer.cs | 35 +++++++++++++++++--
.../RedundantUnsafeContextTests.cs | 19 ++++++++--
2 files changed, 49 insertions(+), 5 deletions(-)
diff --git a/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantUnsafeContextAnalyzer.cs b/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantUnsafeContextAnalyzer.cs
index c7e7e0ab..ca93b05d 100644
--- a/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantUnsafeContextAnalyzer.cs
+++ b/RefactoringEssentials/CSharp/Diagnostics/Synced/RedundanciesInCode/RedundantUnsafeContextAnalyzer.cs
@@ -44,7 +44,7 @@ public override void Initialize(AnalysisContext context)
var model = compilationContext.Compilation.GetSemanticModel(ctx.Tree);
if (model.IsFromGeneratedCode(compilationContext.CancellationToken))
return;
- new GatherVisitor(ctx).Visit(root);
+ new GatherVisitor(ctx, semanticModel).Visit(root);
}
catch (OperationCanceledException) { }
});
@@ -54,10 +54,12 @@ public override void Initialize(AnalysisContext context)
class GatherVisitor : CSharpSyntaxWalker
{
SyntaxTreeAnalysisContext ctx;
+ SemanticModel semanticModel;
- public GatherVisitor(SyntaxTreeAnalysisContext ctx)
+ public GatherVisitor(SyntaxTreeAnalysisContext ctx, SemanticModel semanticModel)
{
this.ctx = ctx;
+ this.semanticModel = semanticModel;
}
class UnsafeState
@@ -161,6 +163,35 @@ public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node
MarkUnsafe();
}
+ public override void VisitIdentifierName(IdentifierNameSyntax node)
+ {
+ base.VisitIdentifierName(node);
+
+ ISymbol symbol = semanticModel.GetSymbolInfo(node).Symbol;
+ if (symbol != null)
+ {
+ switch (symbol.Kind)
+ {
+ case SymbolKind.ArrayType:
+ case SymbolKind.DynamicType:
+ case SymbolKind.ErrorType:
+ case SymbolKind.Event:
+ case SymbolKind.Field:
+ case SymbolKind.Method:
+ case SymbolKind.NamedType:
+ case SymbolKind.Parameter:
+ case SymbolKind.PointerType:
+ case SymbolKind.Property:
+ case SymbolKind.RangeVariable:
+ if (symbol.IsUnsafe())
+ MarkUnsafe();
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
public override void VisitUnsafeStatement(UnsafeStatementSyntax node)
{
if (unsafeStateStack.Count == 0)
diff --git a/Tests/CSharp/Diagnostics/RedundantUnsafeContextTests.cs b/Tests/CSharp/Diagnostics/RedundantUnsafeContextTests.cs
index 4493bd77..2faadf33 100644
--- a/Tests/CSharp/Diagnostics/RedundantUnsafeContextTests.cs
+++ b/Tests/CSharp/Diagnostics/RedundantUnsafeContextTests.cs
@@ -127,14 +127,27 @@ public static void Main(String[] args)
}
[Test]
- public void TestFixed()
+ public void TestUnsafeProperty()
{
Analyze(@"
class Foo
{
- unsafe struct TestStruct
+ class TestStruct
{
- public fixed byte TestVar[32];
+ unsafe byte* UnsafePointer
+ {
+ get {
+ return null;
+ }
+ }
+
+ public IntPtr SafeData {
+ get {
+ unsafe {
+ return new IntPtr(UnsafePointer);
+ }
+ }
+ }
}
}
");
From bf1d4d352bfd8eb729cbf97912020a193fe7bbcf Mon Sep 17 00:00:00 2001
From: Andreas Weizel
Date: Wed, 14 Sep 2016 00:26:41 +0200
Subject: [PATCH 005/236] Brought back accidentally replaced unit test.
---
.../Diagnostics/RedundantUnsafeContextTests.cs | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/Tests/CSharp/Diagnostics/RedundantUnsafeContextTests.cs b/Tests/CSharp/Diagnostics/RedundantUnsafeContextTests.cs
index 2faadf33..02401f93 100644
--- a/Tests/CSharp/Diagnostics/RedundantUnsafeContextTests.cs
+++ b/Tests/CSharp/Diagnostics/RedundantUnsafeContextTests.cs
@@ -126,6 +126,20 @@ public static void Main(String[] args)
}");
}
+ [Test]
+ public void TestFixed()
+ {
+ Analyze(@"
+class Foo
+{
+ unsafe struct TestStruct
+ {
+ public fixed byte TestVar[32];
+ }
+}
+");
+ }
+
[Test]
public void TestUnsafeProperty()
{
From 9c6360a10722a5e6089e0db43f5ae867a870b2ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mike=20Kr=C3=BCger?=
Date: Thu, 15 Sep 2016 11:11:38 +0200
Subject: [PATCH 006/236] Fixed a bug that changed visibility modifiers on
property <-> backing field actions.
---
...yAndBackingFieldCodeRefactoringProvider.cs | 4 ++-
...WithAutoPropertyCodeRefactoringProvider.cs | 14 +++++++----
...ropertyWithPropertyAndBackingFieldTests.cs | 25 +++++++++++++++++++
...tyWithBackingFieldWithAutoPropertyTests.cs | 21 ++++++++++++++++
4 files changed, 58 insertions(+), 6 deletions(-)
diff --git a/RefactoringEssentials/CSharp/CodeRefactorings/Synced/ReplaceAutoPropertyWithPropertyAndBackingFieldCodeRefactoringProvider.cs b/RefactoringEssentials/CSharp/CodeRefactorings/Synced/ReplaceAutoPropertyWithPropertyAndBackingFieldCodeRefactoringProvider.cs
index 92632115..503965a1 100644
--- a/RefactoringEssentials/CSharp/CodeRefactorings/Synced/ReplaceAutoPropertyWithPropertyAndBackingFieldCodeRefactoringProvider.cs
+++ b/RefactoringEssentials/CSharp/CodeRefactorings/Synced/ReplaceAutoPropertyWithPropertyAndBackingFieldCodeRefactoringProvider.cs
@@ -61,12 +61,13 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
var newPropAnno = new SyntaxAnnotation();
var syntaxList = new SyntaxList();
var hasSetter = property.AccessorList.Accessors.Any(acc => acc.IsKind(SyntaxKind.SetAccessorDeclaration));
- var hasGetter = property.AccessorList.Accessors.Any(acc => acc.IsKind(SyntaxKind.GetAccessorDeclaration));
+ var hasGetter = property.AccessorList.Accessors.Any(acc => acc.IsKind (SyntaxKind.GetAccessorDeclaration));
if (hasGetter)
{
var getBody = SyntaxFactory.Block(SyntaxFactory.ReturnStatement(fieldExpression));
var getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, getBody);
+ getter = getter.WithModifiers (property.AccessorList.Accessors.First (acc => acc.IsKind (SyntaxKind.GetAccessorDeclaration)).Modifiers);
syntaxList = syntaxList.Add(getter);
if (!hasSetter)
backingStore = backingStore.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)));
@@ -78,6 +79,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, fieldExpression,
SyntaxFactory.IdentifierName("value"))));
var setter = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, setBody);
+ setter = setter.WithModifiers (property.AccessorList.Accessors.First (acc => acc.IsKind (SyntaxKind.SetAccessorDeclaration)).Modifiers);
syntaxList = syntaxList.Add(setter);
}
var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(syntaxList))
diff --git a/RefactoringEssentials/CSharp/CodeRefactorings/Synced/ReplacePropertyWithBackingFieldWithAutoPropertyCodeRefactoringProvider.cs b/RefactoringEssentials/CSharp/CodeRefactorings/Synced/ReplacePropertyWithBackingFieldWithAutoPropertyCodeRefactoringProvider.cs
index 4bc2c257..9e095dcd 100644
--- a/RefactoringEssentials/CSharp/CodeRefactorings/Synced/ReplacePropertyWithBackingFieldWithAutoPropertyCodeRefactoringProvider.cs
+++ b/RefactoringEssentials/CSharp/CodeRefactorings/Synced/ReplacePropertyWithBackingFieldWithAutoPropertyCodeRefactoringProvider.cs
@@ -73,8 +73,8 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
static bool IsEmptyComputedProperty(PropertyDeclarationSyntax property)
{
- var getter = property.AccessorList.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.GetAccessorDeclaration));
- var setter = property.AccessorList.Accessors.FirstOrDefault(a => a.IsKind(SyntaxKind.SetAccessorDeclaration));
+ var getter = property.AccessorList.Accessors.FirstOrDefault (a => a.IsKind (SyntaxKind.GetAccessorDeclaration));
+ var setter = property.AccessorList.Accessors.FirstOrDefault (a => a.IsKind (SyntaxKind.SetAccessorDeclaration));
return getter != null && setter != null && IsNotImplemented(getter.Body) && IsNotImplemented(setter.Body);
}
static bool IsNotImplemented(BlockSyntax body)
@@ -86,9 +86,13 @@ static bool IsNotImplemented(BlockSyntax body)
static PropertyDeclarationSyntax CreateNewProperty(PropertyDeclarationSyntax property)
- {
- // create new auto property
- var accessorDeclList = new SyntaxList().Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))).Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
+ {
+ var getter = property.AccessorList.Accessors.FirstOrDefault (a => a.IsKind (SyntaxKind.GetAccessorDeclaration));
+ var setter = property.AccessorList.Accessors.FirstOrDefault (a => a.IsKind (SyntaxKind.SetAccessorDeclaration));
+
+ // create new auto property
+ var accessorDeclList = new SyntaxList().Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration).WithModifiers (getter.Modifiers).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)))
+ .Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithModifiers (setter.Modifiers).WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
var newProperty = property.WithAccessorList(SyntaxFactory.AccessorList(accessorDeclList)).WithTrailingTrivia(property.GetTrailingTrivia()).WithAdditionalAnnotations(Formatter.Annotation);
return newProperty;
}
diff --git a/Tests/CSharp/CodeRefactorings/ReplaceAutoPropertyWithPropertyAndBackingFieldTests.cs b/Tests/CSharp/CodeRefactorings/ReplaceAutoPropertyWithPropertyAndBackingFieldTests.cs
index 7fb61906..4c304883 100644
--- a/Tests/CSharp/CodeRefactorings/ReplaceAutoPropertyWithPropertyAndBackingFieldTests.cs
+++ b/Tests/CSharp/CodeRefactorings/ReplaceAutoPropertyWithPropertyAndBackingFieldTests.cs
@@ -211,6 +211,31 @@ public string Test ${
throw new System.NotImplementedException ();
}
}
+}");
+ }
+
+ [Test]
+ public void TestPreserveVisibility()
+ {
+ Test(@"class TestClass
+{
+ public string $Test { get; private set; }
+}", @"class TestClass
+{
+ string test;
+
+ public string Test
+ {
+ get
+ {
+ return test;
+ }
+
+ private set
+ {
+ test = value;
+ }
+ }
}");
}
}
diff --git a/Tests/CSharp/CodeRefactorings/ReplacePropertyWithBackingFieldWithAutoPropertyTests.cs b/Tests/CSharp/CodeRefactorings/ReplacePropertyWithBackingFieldWithAutoPropertyTests.cs
index bf694276..a86b9bfd 100644
--- a/Tests/CSharp/CodeRefactorings/ReplacePropertyWithBackingFieldWithAutoPropertyTests.cs
+++ b/Tests/CSharp/CodeRefactorings/ReplacePropertyWithBackingFieldWithAutoPropertyTests.cs
@@ -225,6 +225,27 @@ class TestClass
{
public int Field { get; set; }
}
+");
+ }
+
+ [Test]
+ public void TestPreserveVisibility()
+ {
+ Test(@"
+class TestClass
+{
+ int field;
+ public int $Field
+ {
+ get { return field; }
+ private set { field = value; }
+ }
+}
+", @"
+class TestClass
+{
+ public int Field { get; private set; }
+}
");
}
}
From ba0965c49a15349cf88d7642c36a73fd43f126c6 Mon Sep 17 00:00:00 2001
From: Andreas Weizel
Date: Sun, 2 Oct 2016 16:41:04 +0200
Subject: [PATCH 007/236] Updated version to 4.4.
---
BuildTools/appveyor.yml | 4 ++--
RefactoringEssentials/Properties/AssemblyInfoBase.cs | 4 ++--
RefactoringEssentials/RefactoringEssentials.Library.nuspec | 4 ++--
RefactoringEssentials/RefactoringEssentials.nuspec | 4 ++--
RefactoringEssentials/RefactoringEssentials.version | 6 +++---
Vsix/source.extension.vsixmanifest | 6 +++---
6 files changed, 14 insertions(+), 14 deletions(-)
diff --git a/BuildTools/appveyor.yml b/BuildTools/appveyor.yml
index 56f1b5a0..0b110857 100644
--- a/BuildTools/appveyor.yml
+++ b/BuildTools/appveyor.yml
@@ -4,7 +4,7 @@
only:
- release
- version: 4.3.{build}
+ version: 4.4.{build}
os: Visual Studio 2015
@@ -34,7 +34,7 @@
only:
- master
- version: 4.3.{build}
+ version: 4.4.{build}
os: Visual Studio 2015
diff --git a/RefactoringEssentials/Properties/AssemblyInfoBase.cs b/RefactoringEssentials/Properties/AssemblyInfoBase.cs
index b395e3f2..161aec0d 100644
--- a/RefactoringEssentials/Properties/AssemblyInfoBase.cs
+++ b/RefactoringEssentials/Properties/AssemblyInfoBase.cs
@@ -9,8 +9,8 @@
[assembly: AssemblyCompany("ICSharpCode")]
[assembly: AssemblyProduct("Refactoring Essentials")]
[assembly: AssemblyCopyright("Copyright 2010-2016 AlphaSierraPapa and Xamarin Inc.")]
-[assembly: AssemblyVersion("4.3.0.0")]
-[assembly: AssemblyFileVersion("4.3.0")]
+[assembly: AssemblyVersion("4.4.0.0")]
+[assembly: AssemblyFileVersion("4.4.0")]
// This sets the default COM visibility of types in the assembly to invisible.
// If you need to expose a type to COM, use [ComVisible(true)] on that type.
diff --git a/RefactoringEssentials/RefactoringEssentials.Library.nuspec b/RefactoringEssentials/RefactoringEssentials.Library.nuspec
index 84d1f4d0..69d5b403 100644
--- a/RefactoringEssentials/RefactoringEssentials.Library.nuspec
+++ b/RefactoringEssentials/RefactoringEssentials.Library.nuspec
@@ -3,7 +3,7 @@
RefactoringEssentials.Library
- 4.3.0
+ 4.4.0Refactoring EssentialsIC#CodeIC#Code
@@ -12,7 +12,7 @@
https://raw.githubusercontent.com/icsharpcode/RefactoringEssentials/master/RefactoringEssentials/Images/refactoringessentials-logo32.pngfalseAnalyzers and Code Fixes as a library, intended for IDE builders
- Please see https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.2 for more information.
+ Please see https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4 for more information.Copyright (c) 2014-2016 AlphaSierraPapaVS 2015 Roslyn Analyzer Refactoring
diff --git a/RefactoringEssentials/RefactoringEssentials.nuspec b/RefactoringEssentials/RefactoringEssentials.nuspec
index 27d6bf6c..d4096ef3 100644
--- a/RefactoringEssentials/RefactoringEssentials.nuspec
+++ b/RefactoringEssentials/RefactoringEssentials.nuspec
@@ -3,7 +3,7 @@
RefactoringEssentials
- 4.3.0
+ 4.4.0Refactoring EssentialsIC#CodeIC#Code
@@ -13,7 +13,7 @@
falseAnalyzers and Code Fixes for Visual Studio 2015 (Roslyn-based). Intended for build integration. If you need Visual Studio integration only, please check out the VSIX (Visual Studio extension) from our Web site.
- Please see https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.2 for more information.
+ Please see https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4 for more information.
Copyright (c) 2014-2016 AlphaSierraPapaVS 2015 Roslyn Analyzer Refactoring
diff --git a/RefactoringEssentials/RefactoringEssentials.version b/RefactoringEssentials/RefactoringEssentials.version
index 42a16854..dd8513e1 100644
--- a/RefactoringEssentials/RefactoringEssentials.version
+++ b/RefactoringEssentials/RefactoringEssentials.version
@@ -1,4 +1,4 @@
-nuget_version=4.3.0
-full_version=4.3.0.0
-release_notes_link=https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.2
+nuget_version=4.4.0
+full_version=4.4.0.0
+release_notes_link=https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4
copyright=Copyright (c) 2014-2016 AlphaSierraPapa
\ No newline at end of file
diff --git a/Vsix/source.extension.vsixmanifest b/Vsix/source.extension.vsixmanifest
index 994894da..b711334b 100644
--- a/Vsix/source.extension.vsixmanifest
+++ b/Vsix/source.extension.vsixmanifest
@@ -2,12 +2,12 @@
-
+ Refactoring Essentials for Visual StudioFree refactorings for C# and Visual Basic (VB) - plus more!license.txt
- https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.2
- https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.2
+ https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4
+ https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4Images\refactoringessentials-logo90.pngImages\refactoringessentials-preview.png
From 19fbd4abf1db91fc82c008de79987e3937022312 Mon Sep 17 00:00:00 2001
From: Andreas Weizel
Date: Sun, 2 Oct 2016 17:35:32 +0200
Subject: [PATCH 008/236] Updated development release version to 4.5.
---
BuildTools/appveyor.yml | 4 ++--
RefactoringEssentials/Properties/AssemblyInfoBase.cs | 4 ++--
RefactoringEssentials/RefactoringEssentials.Library.nuspec | 4 ++--
RefactoringEssentials/RefactoringEssentials.nuspec | 4 ++--
RefactoringEssentials/RefactoringEssentials.version | 6 +++---
Vsix/source.extension.vsixmanifest | 6 +++---
6 files changed, 14 insertions(+), 14 deletions(-)
diff --git a/BuildTools/appveyor.yml b/BuildTools/appveyor.yml
index 0b110857..822c9267 100644
--- a/BuildTools/appveyor.yml
+++ b/BuildTools/appveyor.yml
@@ -4,7 +4,7 @@
only:
- release
- version: 4.4.{build}
+ version: 4.5.{build}
os: Visual Studio 2015
@@ -34,7 +34,7 @@
only:
- master
- version: 4.4.{build}
+ version: 4.5.{build}
os: Visual Studio 2015
diff --git a/RefactoringEssentials/Properties/AssemblyInfoBase.cs b/RefactoringEssentials/Properties/AssemblyInfoBase.cs
index 161aec0d..4d15cd5c 100644
--- a/RefactoringEssentials/Properties/AssemblyInfoBase.cs
+++ b/RefactoringEssentials/Properties/AssemblyInfoBase.cs
@@ -9,8 +9,8 @@
[assembly: AssemblyCompany("ICSharpCode")]
[assembly: AssemblyProduct("Refactoring Essentials")]
[assembly: AssemblyCopyright("Copyright 2010-2016 AlphaSierraPapa and Xamarin Inc.")]
-[assembly: AssemblyVersion("4.4.0.0")]
-[assembly: AssemblyFileVersion("4.4.0")]
+[assembly: AssemblyVersion("4.5.0.0")]
+[assembly: AssemblyFileVersion("4.5.0")]
// This sets the default COM visibility of types in the assembly to invisible.
// If you need to expose a type to COM, use [ComVisible(true)] on that type.
diff --git a/RefactoringEssentials/RefactoringEssentials.Library.nuspec b/RefactoringEssentials/RefactoringEssentials.Library.nuspec
index 69d5b403..b754be37 100644
--- a/RefactoringEssentials/RefactoringEssentials.Library.nuspec
+++ b/RefactoringEssentials/RefactoringEssentials.Library.nuspec
@@ -3,7 +3,7 @@
RefactoringEssentials.Library
- 4.4.0
+ 4.5.0Refactoring EssentialsIC#CodeIC#Code
@@ -12,7 +12,7 @@
https://raw.githubusercontent.com/icsharpcode/RefactoringEssentials/master/RefactoringEssentials/Images/refactoringessentials-logo32.pngfalseAnalyzers and Code Fixes as a library, intended for IDE builders
- Please see https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4 for more information.
+ Please see https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.6 for more information.Copyright (c) 2014-2016 AlphaSierraPapaVS 2015 Roslyn Analyzer Refactoring
diff --git a/RefactoringEssentials/RefactoringEssentials.nuspec b/RefactoringEssentials/RefactoringEssentials.nuspec
index d4096ef3..2ea898fc 100644
--- a/RefactoringEssentials/RefactoringEssentials.nuspec
+++ b/RefactoringEssentials/RefactoringEssentials.nuspec
@@ -3,7 +3,7 @@
RefactoringEssentials
- 4.4.0
+ 4.5.0Refactoring EssentialsIC#CodeIC#Code
@@ -13,7 +13,7 @@
falseAnalyzers and Code Fixes for Visual Studio 2015 (Roslyn-based). Intended for build integration. If you need Visual Studio integration only, please check out the VSIX (Visual Studio extension) from our Web site.
- Please see https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4 for more information.
+ Please see https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.6 for more information.
Copyright (c) 2014-2016 AlphaSierraPapaVS 2015 Roslyn Analyzer Refactoring
diff --git a/RefactoringEssentials/RefactoringEssentials.version b/RefactoringEssentials/RefactoringEssentials.version
index dd8513e1..43bdcfc0 100644
--- a/RefactoringEssentials/RefactoringEssentials.version
+++ b/RefactoringEssentials/RefactoringEssentials.version
@@ -1,4 +1,4 @@
-nuget_version=4.4.0
-full_version=4.4.0.0
-release_notes_link=https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4
+nuget_version=4.5.0
+full_version=4.5.0.0
+release_notes_link=https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.6
copyright=Copyright (c) 2014-2016 AlphaSierraPapa
\ No newline at end of file
diff --git a/Vsix/source.extension.vsixmanifest b/Vsix/source.extension.vsixmanifest
index b711334b..8e3be36b 100644
--- a/Vsix/source.extension.vsixmanifest
+++ b/Vsix/source.extension.vsixmanifest
@@ -2,12 +2,12 @@
-
+ Refactoring Essentials for Visual StudioFree refactorings for C# and Visual Basic (VB) - plus more!license.txt
- https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4
- https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.4
+ https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.6
+ https://github.com/icsharpcode/RefactoringEssentials/wiki/Release-4.6Images\refactoringessentials-logo90.pngImages\refactoringessentials-preview.png
From 7c9fed45d961554627e3957edfdcc120d2063857 Mon Sep 17 00:00:00 2001
From: Siegfried Pammer
Date: Fri, 30 Sep 2016 20:24:34 +0200
Subject: [PATCH 009/236] Add VB to C# converter
---
.../CSharp/Converter/MethodBodyVisitor.cs | 232 +++++
.../CSharp/Converter/NodesVisitor.cs | 863 ++++++++++++++++++
.../CSharp/Converter/VisualBasicConverter.cs | 341 +++++++
.../RefactoringEssentials.csproj | 3 +
RefactoringEssentials/Util/CSharpUtil.cs | 65 +-
5 files changed, 1499 insertions(+), 5 deletions(-)
create mode 100644 RefactoringEssentials/CSharp/Converter/MethodBodyVisitor.cs
create mode 100644 RefactoringEssentials/CSharp/Converter/NodesVisitor.cs
create mode 100644 RefactoringEssentials/CSharp/Converter/VisualBasicConverter.cs
diff --git a/RefactoringEssentials/CSharp/Converter/MethodBodyVisitor.cs b/RefactoringEssentials/CSharp/Converter/MethodBodyVisitor.cs
new file mode 100644
index 00000000..6c1ca2f7
--- /dev/null
+++ b/RefactoringEssentials/CSharp/Converter/MethodBodyVisitor.cs
@@ -0,0 +1,232 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using VBasic = Microsoft.CodeAnalysis.VisualBasic;
+using VBSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax;
+
+namespace RefactoringEssentials.CSharp.Converter
+{
+ public partial class VisualBasicConverter
+ {
+ class MethodBodyVisitor : VBasic.VisualBasicSyntaxVisitor>
+ {
+ SemanticModel semanticModel;
+ NodesVisitor nodesVisitor;
+
+ public MethodBodyVisitor(SemanticModel semanticModel, NodesVisitor nodesVisitor)
+ {
+ this.semanticModel = semanticModel;
+ this.nodesVisitor = nodesVisitor;
+ }
+
+ public override SyntaxList DefaultVisit(SyntaxNode node)
+ {
+ throw new NotImplementedException(node.GetType() + " not implemented!");
+ }
+
+ public override SyntaxList VisitLocalDeclarationStatement(VBSyntax.LocalDeclarationStatementSyntax node)
+ {
+ var modifiers = ConvertModifiers(node.Modifiers);
+
+ var declarations = new List();
+
+ foreach (var declarator in node.Declarators)
+ foreach (var decl in SplitVariableDeclarations(declarator, nodesVisitor, semanticModel))
+ declarations.Add(SyntaxFactory.LocalDeclarationStatement(modifiers, decl.Value));
+
+ return SyntaxFactory.List(declarations);
+ }
+
+ public override SyntaxList VisitExpressionStatement(VBSyntax.ExpressionStatementSyntax node)
+ {
+ return SingleStatement((ExpressionSyntax)node.Expression.Accept(nodesVisitor));
+ }
+
+ public override SyntaxList VisitAssignmentStatement(VBSyntax.AssignmentStatementSyntax node)
+ {
+ var kind = ConvertToken(node.Kind(), TokenContext.Local);
+ return SingleStatement(SyntaxFactory.AssignmentExpression(kind, (ExpressionSyntax)node.Left.Accept(nodesVisitor), (ExpressionSyntax)node.Right.Accept(nodesVisitor)));
+ }
+
+ public override SyntaxList VisitThrowStatement(VBSyntax.ThrowStatementSyntax node)
+ {
+ return SingleStatement(SyntaxFactory.ThrowStatement((ExpressionSyntax)node.Expression?.Accept(nodesVisitor)));
+ }
+
+ public override SyntaxList VisitReturnStatement(VBSyntax.ReturnStatementSyntax node)
+ {
+ return SingleStatement(SyntaxFactory.ReturnStatement((ExpressionSyntax)node.Expression?.Accept(nodesVisitor)));
+ }
+
+ public override SyntaxList VisitYieldStatement(VBSyntax.YieldStatementSyntax node)
+ {
+ return SingleStatement(SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)node.Expression?.Accept(nodesVisitor)));
+ }
+
+ public override SyntaxList VisitSingleLineIfStatement(VBSyntax.SingleLineIfStatementSyntax node)
+ {
+ var condition = (ExpressionSyntax)node.Condition.Accept(nodesVisitor);
+ var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)));
+ ElseClauseSyntax elseClause = null;
+
+ if (node.ElseClause != null)
+ {
+ var elseBlock = SyntaxFactory.Block(node.ElseClause.Statements.SelectMany(s => s.Accept(this)));
+ elseClause = SyntaxFactory.ElseClause(elseBlock);
+ }
+ return SingleStatement(SyntaxFactory.IfStatement(condition, block, elseClause));
+ }
+
+ public override SyntaxList VisitMultiLineIfBlock(VBSyntax.MultiLineIfBlockSyntax node)
+ {
+ var condition = (ExpressionSyntax)node.IfStatement.Condition.Accept(nodesVisitor);
+ var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)));
+ ElseClauseSyntax elseClause = null;
+
+ if (node.ElseBlock != null)
+ {
+ var elseBlock = SyntaxFactory.Block(node.ElseBlock.Statements.SelectMany(s => s.Accept(this)));
+ elseClause = SyntaxFactory.ElseClause(elseBlock);
+ }
+
+ foreach (var elseIf in node.ElseIfBlocks.Reverse())
+ {
+ var elseBlock = SyntaxFactory.Block(elseIf.Statements.SelectMany(s => s.Accept(this)));
+ var ifStmt = SyntaxFactory.IfStatement((ExpressionSyntax)elseIf.ElseIfStatement.Condition.Accept(nodesVisitor), elseBlock, elseClause);
+ elseClause = SyntaxFactory.ElseClause(ifStmt);
+ }
+
+ return SingleStatement(SyntaxFactory.IfStatement(condition, block, elseClause));
+ }
+
+ public override SyntaxList VisitForBlock(VBSyntax.ForBlockSyntax node)
+ {
+ var stmt = node.ForStatement;
+ ExpressionSyntax startValue = (ExpressionSyntax)stmt.FromValue.Accept(nodesVisitor);
+ VariableDeclarationSyntax declaration = null;
+ ExpressionSyntax id;
+ if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax) {
+ var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable;
+ declaration = SplitVariableDeclarations(v, nodesVisitor, semanticModel).Values.Single();
+ declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue))));
+ id = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier);
+ } else {
+ var v = (ExpressionSyntax)stmt.ControlVariable.Accept(nodesVisitor);
+ startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, v, startValue);
+ id = v;
+ }
+
+ var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(nodesVisitor);
+ PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax;
+ ExpressionSyntax condition;
+ if (value == null) {
+ condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(nodesVisitor));
+ } else {
+ condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(nodesVisitor));
+ }
+ if (step == null)
+ step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id);
+ else
+ step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step);
+ var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)));
+ return SingleStatement(SyntaxFactory.ForStatement(
+ declaration,
+ declaration != null ? SyntaxFactory.SeparatedList() : SyntaxFactory.SingletonSeparatedList(startValue),
+ condition,
+ SyntaxFactory.SingletonSeparatedList(step),
+ block));
+ }
+
+ public override SyntaxList VisitForEachBlock(VBSyntax.ForEachBlockSyntax node)
+ {
+ var stmt = node.ForEachStatement;
+
+ TypeSyntax type = null;
+ SyntaxToken id;
+ if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax)
+ {
+ var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable;
+ var declaration = SplitVariableDeclarations(v, nodesVisitor, semanticModel).Values.Single();
+ type = declaration.Type;
+ id = declaration.Variables[0].Identifier;
+ }
+ else
+ {
+ var v = (IdentifierNameSyntax)stmt.ControlVariable.Accept(nodesVisitor);
+ id = v.Identifier;
+ type = SyntaxFactory.ParseTypeName("var");
+ }
+
+ var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)));
+ return SingleStatement(SyntaxFactory.ForEachStatement(
+ type,
+ id,
+ (ExpressionSyntax)stmt.Expression.Accept(nodesVisitor),
+ block
+ ));
+ }
+
+ public override SyntaxList VisitSelectBlock(VBSyntax.SelectBlockSyntax node)
+ {
+ var expr = (ExpressionSyntax)node.SelectStatement.Expression.Accept(nodesVisitor);
+ SwitchStatementSyntax switchStatement;
+ if (ConvertToSwitch(expr, node.CaseBlocks, out switchStatement))
+ return SingleStatement(switchStatement);
+ throw new NotSupportedException();
+ }
+
+ private bool ConvertToSwitch(ExpressionSyntax expr, SyntaxList caseBlocks, out SwitchStatementSyntax switchStatement)
+ {
+ switchStatement = null;
+
+ var sections = new List();
+ foreach (var block in caseBlocks)
+ {
+ var labels = SyntaxFactory.List();
+ foreach (var c in block.CaseStatement.Cases)
+ {
+ if (c is VBSyntax.SimpleCaseClauseSyntax) {
+ var s = (VBSyntax.SimpleCaseClauseSyntax)c;
+ labels.Add(SyntaxFactory.CaseSwitchLabel((ExpressionSyntax)s.Value.Accept(nodesVisitor)));
+ } else if (c is VBSyntax.ElseCaseClauseSyntax) {
+ labels.Add(SyntaxFactory.DefaultSwitchLabel());
+ } else return false;
+ }
+ var list = SyntaxFactory.List(block.Statements.SelectMany(s => s.Accept(this)));
+ sections.Add(SyntaxFactory.SwitchSection(labels, list));
+ }
+ switchStatement = SyntaxFactory.SwitchStatement(expr, SyntaxFactory.List(sections));
+ return true;
+ }
+
+ public override SyntaxList VisitTryBlock(VBSyntax.TryBlockSyntax node)
+ {
+ return base.VisitTryBlock(node);
+ }
+
+ public override SyntaxList VisitSyncLockBlock(VBSyntax.SyncLockBlockSyntax node)
+ {
+ return SingleStatement(SyntaxFactory.LockStatement(
+ (ExpressionSyntax)node.SyncLockStatement.Expression.Accept(nodesVisitor),
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)))
+ ));
+ }
+
+ SyntaxList SingleStatement(StatementSyntax statement)
+ {
+ return SyntaxFactory.SingletonList(statement);
+ }
+
+ SyntaxList SingleStatement(ExpressionSyntax expression)
+ {
+ return SyntaxFactory.SingletonList(SyntaxFactory.ExpressionStatement(expression));
+ }
+ }
+ }
+}
diff --git a/RefactoringEssentials/CSharp/Converter/NodesVisitor.cs b/RefactoringEssentials/CSharp/Converter/NodesVisitor.cs
new file mode 100644
index 00000000..518ec574
--- /dev/null
+++ b/RefactoringEssentials/CSharp/Converter/NodesVisitor.cs
@@ -0,0 +1,863 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using VBSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax;
+using VBasic = Microsoft.CodeAnalysis.VisualBasic;
+
+namespace RefactoringEssentials.CSharp.Converter
+{
+ public partial class VisualBasicConverter
+ {
+ class NodesVisitor : VBasic.VisualBasicSyntaxVisitor
+ {
+ SemanticModel semanticModel;
+ Document targetDocument;
+ CSharpCompilationOptions options;
+ readonly Dictionary additionalFieldDeclarations = new Dictionary();
+
+ public NodesVisitor(SemanticModel semanticModel, Document targetDocument)
+ {
+ this.semanticModel = semanticModel;
+ this.targetDocument = targetDocument;
+ this.options = (CSharpCompilationOptions)targetDocument?.Project.CompilationOptions;
+ }
+
+ public override CSharpSyntaxNode DefaultVisit(SyntaxNode node)
+ {
+ throw new NotImplementedException(node.GetType() + " not implemented!");
+ }
+
+ #region Attributes
+
+ IEnumerable ConvertAttribute(VBSyntax.AttributeListSyntax attributeList)
+ {
+ return attributeList.Attributes.Select(a => (AttributeListSyntax)a.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitAttribute(VBSyntax.AttributeSyntax node)
+ {
+ return SyntaxFactory.AttributeList(
+ node.Target == null ? null : SyntaxFactory.AttributeTargetSpecifier(ConvertToken(node.Target.AttributeModifier)),
+ SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Attribute((NameSyntax)node.Name.Accept(this), (AttributeArgumentListSyntax)node.ArgumentList?.Accept(this)))
+ );
+ }
+
+ #endregion
+
+ public override CSharpSyntaxNode VisitCompilationUnit(VBSyntax.CompilationUnitSyntax node)
+ {
+ var attributes = SyntaxFactory.List(node.Attributes.SelectMany(a => a.AttributeLists).SelectMany(ConvertAttribute));
+ var members = SyntaxFactory.List(node.Members.Select(m => (MemberDeclarationSyntax)m.Accept(this)));
+
+ return SyntaxFactory.CompilationUnit(
+ SyntaxFactory.List(),
+ SyntaxFactory.List(node.Imports.SelectMany(imp => imp.ImportsClauses).Select(c => (UsingDirectiveSyntax)c.Accept(this))),
+ attributes,
+ members
+ );
+ }
+
+ public override CSharpSyntaxNode VisitSimpleImportsClause(VBSyntax.SimpleImportsClauseSyntax node)
+ {
+ if (node.Alias != null)
+ {
+ return SyntaxFactory.UsingDirective(SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(ConvertIdentifier(node.Alias.Identifier, semanticModel))), (NameSyntax)node.Name.Accept(this));
+ }
+ return SyntaxFactory.UsingDirective((NameSyntax)node.Name.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitNamespaceBlock(VBSyntax.NamespaceBlockSyntax node)
+ {
+ var members = node.Members.Select(m => (MemberDeclarationSyntax)m.Accept(this));
+
+ return SyntaxFactory.NamespaceDeclaration(
+ (NameSyntax)node.NamespaceStatement.Name.Accept(this),
+ SyntaxFactory.List(),
+ SyntaxFactory.List(),
+ SyntaxFactory.List(members)
+ );
+ }
+
+ #region Namespace Members
+
+ IEnumerable ConvertMembers(SyntaxList members)
+ {
+ foreach (var member in members.Select(m => (MemberDeclarationSyntax)m.Accept(this)))
+ {
+ BaseFieldDeclarationSyntax[] declarations;
+ if (member is BaseFieldDeclarationSyntax && additionalFieldDeclarations.TryGetValue((BaseFieldDeclarationSyntax)member, out declarations))
+ {
+ foreach (var d in declarations)
+ yield return d;
+ additionalFieldDeclarations.Remove((BaseFieldDeclarationSyntax)member);
+ }
+ else
+ {
+ yield return member;
+ }
+ }
+ }
+
+ public override CSharpSyntaxNode VisitClassBlock(VBSyntax.ClassBlockSyntax node)
+ {
+ var stmt = node.ClassStatement;
+ var attributes = SyntaxFactory.List(stmt.AttributeLists.SelectMany(ConvertAttribute));
+ var members = SyntaxFactory.List(ConvertMembers(node.Members));
+
+ TypeParameterListSyntax parameters;
+ SyntaxList constraints;
+ SplitTypeParameters(stmt.TypeParameterList, out parameters, out constraints);
+
+ return SyntaxFactory.ClassDeclaration(
+ attributes,
+ ConvertModifiers(stmt.Modifiers),
+ ConvertIdentifier(stmt.Identifier, semanticModel),
+ parameters,
+ ConvertInheritsAndImplements(node.Inherits, node.Implements),
+ constraints,
+ members
+ );
+ }
+
+ private BaseListSyntax ConvertInheritsAndImplements(SyntaxList inherits, SyntaxList implements)
+ {
+ if (inherits.Count + implements.Count == 0)
+ return null;
+ var baseTypes = new List();
+ foreach (var t in inherits.SelectMany(c => c.Types).Concat(implements.SelectMany(c => c.Types)))
+ baseTypes.Add(SyntaxFactory.SimpleBaseType((TypeSyntax)t.Accept(this)));
+ return SyntaxFactory.BaseList(SyntaxFactory.SeparatedList(baseTypes));
+ }
+
+ public override CSharpSyntaxNode VisitModuleBlock(VBSyntax.ModuleBlockSyntax node)
+ {
+ var stmt = node.ModuleStatement;
+ var attributes = SyntaxFactory.List(stmt.AttributeLists.SelectMany(ConvertAttribute));
+ var members = SyntaxFactory.List(ConvertMembers(node.Members));
+
+ TypeParameterListSyntax parameters;
+ SyntaxList constraints;
+ SplitTypeParameters(stmt.TypeParameterList, out parameters, out constraints);
+
+ return SyntaxFactory.ClassDeclaration(
+ attributes,
+ ConvertModifiers(stmt.Modifiers).Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)),
+ ConvertIdentifier(stmt.Identifier, semanticModel),
+ parameters,
+ ConvertInheritsAndImplements(node.Inherits, node.Implements),
+ constraints,
+ members
+ );
+ }
+
+ public override CSharpSyntaxNode VisitStructureBlock(VBSyntax.StructureBlockSyntax node)
+ {
+ var stmt = node.StructureStatement;
+ var attributes = SyntaxFactory.List(stmt.AttributeLists.SelectMany(ConvertAttribute));
+ var members = SyntaxFactory.List(ConvertMembers(node.Members));
+
+ TypeParameterListSyntax parameters;
+ SyntaxList constraints;
+ SplitTypeParameters(stmt.TypeParameterList, out parameters, out constraints);
+
+ return SyntaxFactory.StructDeclaration(
+ attributes,
+ ConvertModifiers(stmt.Modifiers),
+ ConvertIdentifier(stmt.Identifier, semanticModel),
+ parameters,
+ ConvertInheritsAndImplements(node.Inherits, node.Implements),
+ constraints,
+ members
+ );
+ }
+
+ public override CSharpSyntaxNode VisitInterfaceBlock(VBSyntax.InterfaceBlockSyntax node)
+ {
+ var stmt = node.InterfaceStatement;
+ var attributes = SyntaxFactory.List(stmt.AttributeLists.SelectMany(ConvertAttribute));
+ var members = SyntaxFactory.List(ConvertMembers(node.Members));
+
+ TypeParameterListSyntax parameters;
+ SyntaxList constraints;
+ SplitTypeParameters(stmt.TypeParameterList, out parameters, out constraints);
+
+ return SyntaxFactory.InterfaceDeclaration(
+ attributes,
+ ConvertModifiers(stmt.Modifiers),
+ ConvertIdentifier(stmt.Identifier, semanticModel),
+ parameters,
+ ConvertInheritsAndImplements(node.Inherits, node.Implements),
+ constraints,
+ members
+ );
+ }
+
+ public override CSharpSyntaxNode VisitEnumBlock(VBSyntax.EnumBlockSyntax node)
+ {
+ var stmt = node.EnumStatement;
+ // we can cast to SimpleAsClause because other type make no sense as enum-type.
+ var asClause = (VBSyntax.SimpleAsClauseSyntax)stmt.UnderlyingType;
+ var attributes = stmt.AttributeLists.SelectMany(ConvertAttribute);
+ BaseListSyntax baseList = null;
+ if (asClause != null)
+ {
+ baseList = SyntaxFactory.BaseList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.SimpleBaseType((TypeSyntax)asClause.Type.Accept(this))));
+ if (asClause.AttributeLists.Count > 0)
+ {
+ attributes = attributes.Concat(
+ SyntaxFactory.AttributeList(
+ SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.ReturnKeyword)),
+ SyntaxFactory.SeparatedList(asClause.AttributeLists.SelectMany(l => ConvertAttribute(l).SelectMany(a => a.Attributes)))
+ )
+ );
+ }
+ }
+ var members = SyntaxFactory.SeparatedList(node.Members.Select(m => (EnumMemberDeclarationSyntax)m.Accept(this)));
+ return SyntaxFactory.EnumDeclaration(
+ SyntaxFactory.List(attributes),
+ ConvertModifiers(stmt.Modifiers),
+ ConvertIdentifier(stmt.Identifier, semanticModel),
+ baseList,
+ members
+ );
+ }
+
+ public override CSharpSyntaxNode VisitEnumMemberDeclaration(VBSyntax.EnumMemberDeclarationSyntax node)
+ {
+ var attributes = SyntaxFactory.List(node.AttributeLists.SelectMany(ConvertAttribute));
+ return SyntaxFactory.EnumMemberDeclaration(
+ attributes,
+ ConvertIdentifier(node.Identifier, semanticModel),
+ (EqualsValueClauseSyntax)node.Initializer?.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitDelegateStatement(VBSyntax.DelegateStatementSyntax node)
+ {
+ var attributes = node.AttributeLists.SelectMany(ConvertAttribute);
+
+ TypeParameterListSyntax typeParameters;
+ SyntaxList constraints;
+ SplitTypeParameters(node.TypeParameterList, out typeParameters, out constraints);
+
+ TypeSyntax returnType;
+ var asClause = node.AsClause;
+ if (asClause == null)
+ {
+ returnType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword));
+ }
+ else
+ {
+ returnType = (TypeSyntax)asClause.Type.Accept(this);
+ if (asClause.AttributeLists.Count > 0)
+ {
+ attributes = attributes.Concat(
+ SyntaxFactory.AttributeList(
+ SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.ReturnKeyword)),
+ SyntaxFactory.SeparatedList(asClause.AttributeLists.SelectMany(l => ConvertAttribute(l).SelectMany(a => a.Attributes)))
+ )
+ );
+ }
+ }
+
+ return SyntaxFactory.DelegateDeclaration(
+ SyntaxFactory.List(attributes),
+ ConvertModifiers(node.Modifiers),
+ returnType,
+ ConvertIdentifier(node.Identifier, semanticModel),
+ typeParameters,
+ (ParameterListSyntax)node.ParameterList?.Accept(this),
+ constraints
+ );
+ }
+
+ #endregion
+
+ #region Type Members
+
+ public override CSharpSyntaxNode VisitFieldDeclaration(VBSyntax.FieldDeclarationSyntax node)
+ {
+ var attributes = node.AttributeLists.SelectMany(ConvertAttribute);
+ var modifiers = ConvertModifiers(node.Modifiers);
+ var key = SyntaxFactory.FieldDeclaration(SyntaxFactory.VariableDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword))));
+ var declarations = new List(node.Declarators.Count);
+
+ foreach (var declarator in node.Declarators)
+ {
+ foreach (var decl in SplitVariableDeclarations(declarator, this, semanticModel).Values)
+ {
+ declarations.Add(SyntaxFactory.FieldDeclaration(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ decl
+ ));
+ }
+ }
+
+ additionalFieldDeclarations.Add(key, declarations.ToArray());
+ return key;
+ }
+
+ public override CSharpSyntaxNode VisitPropertyBlock(VBSyntax.PropertyBlockSyntax node)
+ {
+ return base.VisitPropertyBlock(node);
+ }
+
+ public override CSharpSyntaxNode VisitMethodBlock(VBSyntax.MethodBlockSyntax node)
+ {
+ var block = node.SubOrFunctionStatement;
+ var attributes = block.AttributeLists.SelectMany(ConvertAttribute);
+ var modifiers = ConvertModifiers(block.Modifiers);
+
+ return SyntaxFactory.MethodDeclaration(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ (TypeSyntax)block.AsClause?.Type.Accept(this) ?? SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)),
+ null,
+ ConvertIdentifier(block.Identifier, semanticModel),
+ null,
+ (ParameterListSyntax)block.ParameterList.Accept(this),
+ SyntaxFactory.List(),
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this)))),
+ null
+ );
+ }
+
+ public override CSharpSyntaxNode VisitEventBlock(VBSyntax.EventBlockSyntax node)
+ {
+ return base.VisitEventBlock(node);
+ }
+
+ public override CSharpSyntaxNode VisitEventStatement(VBSyntax.EventStatementSyntax node)
+ {
+ return base.VisitEventStatement(node);
+ }
+
+ public override CSharpSyntaxNode VisitOperatorBlock(VBSyntax.OperatorBlockSyntax node)
+ {
+ var block = node.OperatorStatement;
+ var attributes = block.AttributeLists.SelectMany(ConvertAttribute);
+ var modifiers = ConvertModifiers(block.Modifiers);
+ return SyntaxFactory.OperatorDeclaration(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ (TypeSyntax)block.AsClause?.Type.Accept(this) ?? SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)),
+ ConvertToken(block.OperatorToken),
+ (ParameterListSyntax)block.ParameterList.Accept(this),
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this)))),
+ null
+ );
+ }
+
+ public override CSharpSyntaxNode VisitConstructorBlock(VBSyntax.ConstructorBlockSyntax node)
+ {
+ var block = node.BlockStatement;
+ var attributes = block.AttributeLists.SelectMany(ConvertAttribute);
+ var modifiers = ConvertModifiers(block.Modifiers);
+ return SyntaxFactory.ConstructorDeclaration(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ ConvertIdentifier(node.GetAncestor().BlockStatement.Identifier, semanticModel),
+ (ParameterListSyntax)block.ParameterList.Accept(this),
+ null,
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this))))
+ );
+ }
+
+ public override CSharpSyntaxNode VisitParameterList(VBSyntax.ParameterListSyntax node)
+ {
+ if (node.Parent is VBSyntax.PropertyStatementSyntax)
+ {
+ return SyntaxFactory.BracketedParameterList(SyntaxFactory.SeparatedList(node.Parameters.Select(p => (ParameterSyntax)p.Accept(this))));
+ }
+ return SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(node.Parameters.Select(p => (ParameterSyntax)p.Accept(this))));
+ }
+
+ public override CSharpSyntaxNode VisitParameter(VBSyntax.ParameterSyntax node)
+ {
+ var id = ConvertIdentifier(node.Identifier.Identifier, semanticModel);
+ var returnType = (TypeSyntax)node.AsClause?.Type.Accept(this);
+ if (returnType != null && !node.Identifier.Nullable.IsKind(SyntaxKind.None))
+ {
+ var arrayType = returnType as ArrayTypeSyntax;
+ if (arrayType == null)
+ {
+ returnType = SyntaxFactory.NullableType(returnType);
+ }
+ else
+ {
+ returnType = arrayType.WithElementType(SyntaxFactory.NullableType(arrayType.ElementType));
+ }
+ }
+ EqualsValueClauseSyntax @default = null;
+ if (node.Default != null)
+ {
+ @default = SyntaxFactory.EqualsValueClause((ExpressionSyntax)node.Default?.Value.Accept(this));
+ }
+ var attributes = node.AttributeLists.SelectMany(ConvertAttribute).ToList();
+ int outAttributeIndex = attributes.FindIndex(a => a.Attributes.Single().Name.ToString() == "Out");
+ var modifiers = ConvertModifiers(node.Modifiers);
+ if (outAttributeIndex > -1) {
+ attributes.RemoveAt(outAttributeIndex);
+ modifiers = modifiers.Replace(SyntaxFactory.Token(SyntaxKind.RefKeyword), SyntaxFactory.Token(SyntaxKind.OutKeyword));
+ }
+ return SyntaxFactory.Parameter(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ returnType,
+ id,
+ @default
+ );
+ }
+
+ #endregion
+
+ #region Expressions
+
+ public override CSharpSyntaxNode VisitCTypeExpression(VBSyntax.CTypeExpressionSyntax node)
+ {
+ return SyntaxFactory.CastExpression(
+ (TypeSyntax)node.Type.Accept(this),
+ (ExpressionSyntax)node.Expression.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitPredefinedCastExpression(VBSyntax.PredefinedCastExpressionSyntax node)
+ {
+ if (node.Keyword.IsKind(VBasic.SyntaxKind.CDateKeyword))
+ {
+ return SyntaxFactory.CastExpression(
+ SyntaxFactory.ParseTypeName("DateTime"),
+ (ExpressionSyntax)node.Expression.Accept(this)
+ );
+ }
+ return SyntaxFactory.CastExpression(
+ SyntaxFactory.PredefinedType(ConvertToken(node.Keyword)),
+ (ExpressionSyntax)node.Expression.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitTryCastExpression(VBSyntax.TryCastExpressionSyntax node)
+ {
+ return SyntaxFactory.BinaryExpression(
+ SyntaxKind.AsExpression,
+ (ExpressionSyntax)node.Expression.Accept(this),
+ (TypeSyntax)node.Type.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitLiteralExpression(VBSyntax.LiteralExpressionSyntax node)
+ {
+ return Literal(node.Token.Value);
+ }
+
+ public override CSharpSyntaxNode VisitInterpolatedStringExpression(VBSyntax.InterpolatedStringExpressionSyntax node)
+ {
+ return SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), SyntaxFactory.List(node.Contents.Select(c => (InterpolatedStringContentSyntax)c.Accept(this))));
+ }
+
+ public override CSharpSyntaxNode VisitInterpolatedStringText(VBSyntax.InterpolatedStringTextSyntax node)
+ {
+ return SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(default(SyntaxTriviaList), SyntaxKind.InterpolatedStringTextToken, node.TextToken.Text, node.TextToken.ValueText, default(SyntaxTriviaList)));
+ }
+
+ public override CSharpSyntaxNode VisitInterpolation(VBSyntax.InterpolationSyntax node)
+ {
+ return SyntaxFactory.Interpolation((ExpressionSyntax)node.Expression.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitInterpolationFormatClause(VBSyntax.InterpolationFormatClauseSyntax node)
+ {
+ return base.VisitInterpolationFormatClause(node);
+ }
+
+ public override CSharpSyntaxNode VisitMeExpression(VBSyntax.MeExpressionSyntax node)
+ {
+ return SyntaxFactory.ThisExpression();
+ }
+
+ public override CSharpSyntaxNode VisitMyBaseExpression(VBSyntax.MyBaseExpressionSyntax node)
+ {
+ return SyntaxFactory.BaseExpression();
+ }
+
+ public override CSharpSyntaxNode VisitParenthesizedExpression(VBSyntax.ParenthesizedExpressionSyntax node)
+ {
+ return SyntaxFactory.ParenthesizedExpression((ExpressionSyntax)node.Expression.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitMemberAccessExpression(VBSyntax.MemberAccessExpressionSyntax node)
+ {
+ var left = (ExpressionSyntax)node.Expression?.Accept(this);
+ if (left == null)
+ return SyntaxFactory.MemberBindingExpression((SimpleNameSyntax)node.Name.Accept(this));
+ else
+ return SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, left, (SimpleNameSyntax)node.Name.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitConditionalAccessExpression(VBSyntax.ConditionalAccessExpressionSyntax node)
+ {
+ return SyntaxFactory.ConditionalAccessExpression((ExpressionSyntax)node.Expression.Accept(this), (ExpressionSyntax)node.WhenNotNull.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitArgumentList(VBSyntax.ArgumentListSyntax node)
+ {
+ if (node.Parent.IsKind(VBasic.SyntaxKind.Attribute))
+ {
+ return SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(node.Arguments.Select(ToAttributeArgument)));
+ }
+ return SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(node.Arguments.Select(a => (ArgumentSyntax)a.Accept(this))));
+ }
+
+ public override CSharpSyntaxNode VisitSimpleArgument(VBSyntax.SimpleArgumentSyntax node)
+ {
+ int argID = ((VBSyntax.ArgumentListSyntax)node.Parent).Arguments.IndexOf(node);
+ var invocation = node.Parent.Parent;
+ if (invocation is VBSyntax.ArrayCreationExpressionSyntax)
+ return node.Expression.Accept(this);
+ var symbol = invocation.TypeSwitch(
+ (VBSyntax.InvocationExpressionSyntax e) => ExtractMatch(semanticModel.GetSymbolInfo(e)) as IMethodSymbol,
+ (VBSyntax.ObjectCreationExpressionSyntax e) => ExtractMatch(semanticModel.GetSymbolInfo(e)) as IMethodSymbol,
+ _ => { throw new NotSupportedException(); }
+ );
+ SyntaxToken token = default(SyntaxToken);
+ if (symbol != null)
+ {
+ var p = symbol.Parameters[argID];
+ switch (p.RefKind)
+ {
+ case RefKind.None:
+ token = default(SyntaxToken);
+ break;
+ case RefKind.Ref:
+ token = SyntaxFactory.Token(SyntaxKind.RefKeyword);
+ break;
+ case RefKind.Out:
+ token = SyntaxFactory.Token(SyntaxKind.OutKeyword);
+ break;
+ default:
+ throw new ArgumentOutOfRangeException();
+ }
+ }
+ return SyntaxFactory.Argument(
+ node.IsNamed ? SyntaxFactory.NameColon((IdentifierNameSyntax)node.NameColonEquals.Name.Accept(this)) : null,
+ token,
+ (ExpressionSyntax)node.Expression.Accept(this)
+ );
+ }
+
+ private ISymbol ExtractMatch(SymbolInfo info)
+ {
+ if (info.Symbol == null && info.CandidateSymbols.Length == 0)
+ return null;
+ if (info.Symbol != null)
+ return info.Symbol;
+ if (info.CandidateSymbols.Length == 1)
+ return info.CandidateSymbols[0];
+ return null;
+ }
+
+ private AttributeArgumentSyntax ToAttributeArgument(VBSyntax.ArgumentSyntax arg)
+ {
+ if (!(arg is VBSyntax.SimpleArgumentSyntax))
+ throw new NotSupportedException();
+ var a = (VBSyntax.SimpleArgumentSyntax)arg;
+ var attr = SyntaxFactory.AttributeArgument((ExpressionSyntax)a.Expression.Accept(this));
+ if (a.IsNamed)
+ {
+ attr = attr.WithNameEquals(SyntaxFactory.NameEquals((IdentifierNameSyntax)a.NameColonEquals.Name.Accept(this)));
+ }
+ return attr;
+ }
+
+ public override CSharpSyntaxNode VisitNameOfExpression(VBSyntax.NameOfExpressionSyntax node)
+ {
+ return SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName("nameof"), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument((ExpressionSyntax)node.Argument.Accept(this)))));
+ }
+
+ public override CSharpSyntaxNode VisitEqualsValue(VBSyntax.EqualsValueSyntax node)
+ {
+ return SyntaxFactory.EqualsValueClause((ExpressionSyntax)node.Value.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitAnonymousObjectCreationExpression(VBSyntax.AnonymousObjectCreationExpressionSyntax node)
+ {
+ return base.VisitAnonymousObjectCreationExpression(node);
+ }
+
+ public override CSharpSyntaxNode VisitObjectCreationExpression(VBSyntax.ObjectCreationExpressionSyntax node)
+ {
+ return SyntaxFactory.ObjectCreationExpression(
+ (TypeSyntax)node.Type.Accept(this),
+ (ArgumentListSyntax)node.ArgumentList?.Accept(this),
+ (InitializerExpressionSyntax)node.Initializer?.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitArrayCreationExpression(VBSyntax.ArrayCreationExpressionSyntax node)
+ {
+ IEnumerable arguments;
+ if (node.ArrayBounds != null)
+ arguments = node.ArrayBounds.Arguments.Select(a => IncreaseArrayUpperBoundExpression(((VBSyntax.SimpleArgumentSyntax)a).Expression));
+ else
+ arguments = Enumerable.Empty();
+ var bounds = SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SeparatedList(arguments)));
+ return SyntaxFactory.ArrayCreationExpression(
+ SyntaxFactory.ArrayType((TypeSyntax)node.Type.Accept(this), bounds),
+ (InitializerExpressionSyntax)node.Initializer?.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitCollectionInitializer(VBSyntax.CollectionInitializerSyntax node)
+ {
+ if (node.Initializers.Count == 0 && node.Parent is VBSyntax.ArrayCreationExpressionSyntax)
+ return null;
+ return SyntaxFactory.InitializerExpression(SyntaxKind.CollectionInitializerExpression, SyntaxFactory.SeparatedList(node.Initializers.Select(i => (ExpressionSyntax)i.Accept(this))));
+ }
+
+ ExpressionSyntax IncreaseArrayUpperBoundExpression(VBSyntax.ExpressionSyntax expr)
+ {
+ var constant = semanticModel.GetConstantValue(expr);
+ if (constant.HasValue && constant.Value is int)
+ return SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal((int)constant.Value + 1));
+
+ return SyntaxFactory.BinaryExpression(
+ SyntaxKind.SubtractExpression,
+ (ExpressionSyntax)expr.Accept(this), SyntaxFactory.Token(SyntaxKind.PlusToken), SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)));
+ }
+
+ public override CSharpSyntaxNode VisitBinaryConditionalExpression(VBSyntax.BinaryConditionalExpressionSyntax node)
+ {
+ return SyntaxFactory.BinaryExpression(
+ SyntaxKind.CoalesceExpression,
+ (ExpressionSyntax)node.FirstExpression.Accept(this),
+ (ExpressionSyntax)node.SecondExpression.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitTernaryConditionalExpression(VBSyntax.TernaryConditionalExpressionSyntax node)
+ {
+ return SyntaxFactory.ConditionalExpression(
+ (ExpressionSyntax)node.Condition.Accept(this),
+ (ExpressionSyntax)node.WhenTrue.Accept(this),
+ (ExpressionSyntax)node.WhenFalse.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitTypeOfExpression(VBSyntax.TypeOfExpressionSyntax node)
+ {
+ var expr = SyntaxFactory.BinaryExpression(
+ SyntaxKind.IsExpression,
+ (ExpressionSyntax)node.Expression.Accept(this),
+ (TypeSyntax)node.Type.Accept(this)
+ );
+ if (node.IsKind(VBasic.SyntaxKind.TypeOfIsNotExpression))
+ return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, expr);
+ else
+ return expr;
+ }
+
+ public override CSharpSyntaxNode VisitUnaryExpression(VBSyntax.UnaryExpressionSyntax node)
+ {
+ var expr = (ExpressionSyntax)node.Operand.Accept(this);
+ if (node.IsKind(VBasic.SyntaxKind.AddressOfExpression))
+ return expr;
+ var kind = ConvertToken(VBasic.VisualBasicExtensions.Kind(node), TokenContext.Local);
+ return SyntaxFactory.PrefixUnaryExpression(
+ kind,
+ SyntaxFactory.Token(CSharpUtil.GetExpressionOperatorTokenKind(kind)),
+ expr
+ );
+ }
+
+ public override CSharpSyntaxNode VisitBinaryExpression(VBSyntax.BinaryExpressionSyntax node)
+ {
+ if (node.IsKind(VBasic.SyntaxKind.IsExpression))
+ {
+ ExpressionSyntax otherArgument = null;
+ if (node.Left.IsKind(VBasic.SyntaxKind.NothingLiteralExpression))
+ {
+ otherArgument = (ExpressionSyntax)node.Right.Accept(this);
+ }
+ if (node.Right.IsKind(VBasic.SyntaxKind.NothingLiteralExpression))
+ {
+ otherArgument = (ExpressionSyntax)node.Left.Accept(this);
+ }
+ if (otherArgument != null)
+ {
+ return SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, otherArgument, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
+ }
+ }
+ if (node.IsKind(VBasic.SyntaxKind.IsNotExpression))
+ {
+ ExpressionSyntax otherArgument = null;
+ if (node.Left.IsKind(VBasic.SyntaxKind.NothingLiteralExpression))
+ {
+ otherArgument = (ExpressionSyntax)node.Right.Accept(this);
+ }
+ if (node.Right.IsKind(VBasic.SyntaxKind.NothingLiteralExpression))
+ {
+ otherArgument = (ExpressionSyntax)node.Left.Accept(this);
+ }
+ if (otherArgument != null)
+ {
+ return SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, otherArgument, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
+ }
+ }
+ var kind = ConvertToken(VBasic.VisualBasicExtensions.Kind(node), TokenContext.Local);
+ return SyntaxFactory.BinaryExpression(
+ kind,
+ (ExpressionSyntax)node.Left.Accept(this),
+ SyntaxFactory.Token(CSharpUtil.GetExpressionOperatorTokenKind(kind)),
+ (ExpressionSyntax)node.Right.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitInvocationExpression(VBSyntax.InvocationExpressionSyntax node)
+ {
+ return SyntaxFactory.InvocationExpression(
+ (ExpressionSyntax)node.Expression.Accept(this),
+ (ArgumentListSyntax)node.ArgumentList.Accept(this)
+ );
+ }
+
+ public override CSharpSyntaxNode VisitSingleLineLambdaExpression(VBSyntax.SingleLineLambdaExpressionSyntax node)
+ {
+ CSharpSyntaxNode body;
+ if (node.Body is VBSyntax.ExpressionSyntax)
+ body = node.Body.Accept(this);
+ else
+ {
+ var stmt = node.Body.Accept(new MethodBodyVisitor(semanticModel, this));
+ if (stmt.Count == 1)
+ body = stmt[0];
+ else
+ {
+ body = SyntaxFactory.Block(stmt);
+ }
+ }
+ var param = (ParameterListSyntax)node.SubOrFunctionHeader.ParameterList.Accept(this);
+ if (param.Parameters.Count == 1)
+ return SyntaxFactory.SimpleLambdaExpression(param.Parameters[0], body);
+ return SyntaxFactory.ParenthesizedLambdaExpression(param, body);
+ }
+
+ public override CSharpSyntaxNode VisitMultiLineLambdaExpression(VBSyntax.MultiLineLambdaExpressionSyntax node)
+ {
+ var body = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this))));
+ var param = (ParameterListSyntax)node.SubOrFunctionHeader.ParameterList.Accept(this);
+ if (param.Parameters.Count == 1)
+ return SyntaxFactory.SimpleLambdaExpression(param.Parameters[0], body);
+ return SyntaxFactory.ParenthesizedLambdaExpression(param, body);
+ }
+
+ #endregion
+
+ #region Type Name / Modifier
+
+ public override CSharpSyntaxNode VisitPredefinedType(VBSyntax.PredefinedTypeSyntax node)
+ {
+ return SyntaxFactory.PredefinedType(ConvertToken(node.Keyword));
+ }
+
+ public override CSharpSyntaxNode VisitNullableType(VBSyntax.NullableTypeSyntax node)
+ {
+ return SyntaxFactory.NullableType((TypeSyntax)node.ElementType.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitArrayType(VBSyntax.ArrayTypeSyntax node)
+ {
+ return SyntaxFactory.ArrayType((TypeSyntax)node.ElementType.Accept(this), SyntaxFactory.List(node.RankSpecifiers.Select(r => (ArrayRankSpecifierSyntax)r.Accept(this))));
+ }
+
+ public override CSharpSyntaxNode VisitArrayRankSpecifier(VBSyntax.ArrayRankSpecifierSyntax node)
+ {
+ return SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SeparatedList(Enumerable.Repeat(SyntaxFactory.OmittedArraySizeExpression(), node.Rank)));
+ }
+
+ private void SplitTypeParameters(VBSyntax.TypeParameterListSyntax typeParameterList, out TypeParameterListSyntax parameters, out SyntaxList constraints)
+ {
+ parameters = null;
+ constraints = SyntaxFactory.List();
+ if (typeParameterList == null)
+ return;
+ var paramList = new List();
+ var constraintList = new List();
+ foreach (var p in typeParameterList.Parameters)
+ {
+ var tp = (TypeParameterSyntax)p.Accept(this);
+ paramList.Add(tp);
+ constraintList.Add((TypeParameterConstraintClauseSyntax)p.TypeParameterConstraintClause.Accept(this));
+ }
+ parameters = SyntaxFactory.TypeParameterList(SyntaxFactory.SeparatedList(paramList));
+ constraints = SyntaxFactory.List(constraintList);
+ }
+
+ public override CSharpSyntaxNode VisitTypeParameter(VBSyntax.TypeParameterSyntax node)
+ {
+ SyntaxToken variance = default(SyntaxToken);
+ if (!node.VarianceKeyword.IsKind(VBasic.SyntaxKind.None))
+ {
+ variance = SyntaxFactory.Token(node.VarianceKeyword.IsKind(VBasic.SyntaxKind.InKeyword) ? SyntaxKind.InKeyword : SyntaxKind.OutKeyword);
+ }
+ return SyntaxFactory.TypeParameter(SyntaxFactory.List(), variance, ConvertIdentifier(node.Identifier, semanticModel));
+ }
+
+ public override CSharpSyntaxNode VisitTypeParameterSingleConstraintClause(VBSyntax.TypeParameterSingleConstraintClauseSyntax node)
+ {
+ var id = SyntaxFactory.IdentifierName(ConvertIdentifier(((VBSyntax.TypeParameterSyntax)node.Parent).Identifier, semanticModel));
+ return SyntaxFactory.TypeParameterConstraintClause(id, SyntaxFactory.SingletonSeparatedList((TypeParameterConstraintSyntax)node.Constraint.Accept(this)));
+ }
+
+ public override CSharpSyntaxNode VisitTypeParameterMultipleConstraintClause(VBSyntax.TypeParameterMultipleConstraintClauseSyntax node)
+ {
+ var id = SyntaxFactory.IdentifierName(ConvertIdentifier(((VBSyntax.TypeParameterSyntax)node.Parent).Identifier, semanticModel));
+ return SyntaxFactory.TypeParameterConstraintClause(id, SyntaxFactory.SeparatedList(node.Constraints.Select(c => (TypeParameterConstraintSyntax)c.Accept(this))));
+ }
+
+ public override CSharpSyntaxNode VisitSpecialConstraint(VBSyntax.SpecialConstraintSyntax node)
+ {
+ if (node.ConstraintKeyword.IsKind(VBasic.SyntaxKind.NewKeyword))
+ return SyntaxFactory.ConstructorConstraint();
+ return SyntaxFactory.ClassOrStructConstraint(node.IsKind(VBasic.SyntaxKind.ClassConstraint) ? SyntaxKind.ClassConstraint : SyntaxKind.StructConstraint);
+ }
+
+ public override CSharpSyntaxNode VisitTypeConstraint(VBSyntax.TypeConstraintSyntax node)
+ {
+ return SyntaxFactory.TypeConstraint((TypeSyntax)node.Type.Accept(this));
+ }
+
+ #endregion
+
+ #region NameSyntax
+
+ public override CSharpSyntaxNode VisitIdentifierName(VBSyntax.IdentifierNameSyntax node)
+ {
+ return SyntaxFactory.IdentifierName(ConvertIdentifier(node.Identifier, semanticModel, node.Parent is VBSyntax.AsClauseSyntax));
+ }
+
+ public override CSharpSyntaxNode VisitQualifiedName(VBSyntax.QualifiedNameSyntax node)
+ {
+ return SyntaxFactory.QualifiedName((NameSyntax)node.Left.Accept(this), (SimpleNameSyntax)node.Right.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitGenericName(VBSyntax.GenericNameSyntax node)
+ {
+ return SyntaxFactory.GenericName(ConvertIdentifier(node.Identifier, semanticModel), (TypeArgumentListSyntax)node.TypeArgumentList?.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitTypeArgumentList(VBSyntax.TypeArgumentListSyntax node)
+ {
+ return SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(node.Arguments.Select(a => (TypeSyntax)a.Accept(this))));
+ }
+
+ #endregion
+ }
+ }
+}
diff --git a/RefactoringEssentials/CSharp/Converter/VisualBasicConverter.cs b/RefactoringEssentials/CSharp/Converter/VisualBasicConverter.cs
new file mode 100644
index 00000000..18f0a855
--- /dev/null
+++ b/RefactoringEssentials/CSharp/Converter/VisualBasicConverter.cs
@@ -0,0 +1,341 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using VBasic = Microsoft.CodeAnalysis.VisualBasic;
+using VBSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax;
+using RefactoringEssentials.Converter;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace RefactoringEssentials.CSharp.Converter
+{
+ public partial class VisualBasicConverter
+ {
+ enum TokenContext
+ {
+ Global,
+ InterfaceOrModule,
+ Member,
+ VariableOrConst,
+ Local
+ }
+
+ public static CSharpSyntaxNode Convert(VBasic.VisualBasicSyntaxNode input, SemanticModel semanticModel, Document targetDocument)
+ {
+ return input.Accept(new NodesVisitor(semanticModel, targetDocument));
+ }
+
+ public static ConversionResult ConvertText(string text, MetadataReference[] references)
+ {
+ if (text == null)
+ throw new ArgumentNullException(nameof(text));
+ if (references == null)
+ throw new ArgumentNullException(nameof(references));
+ var tree = VBasic.SyntaxFactory.ParseSyntaxTree(SourceText.From(text));
+ var compilation = VBasic.VisualBasicCompilation.Create("Conversion", new[] { tree }, references);
+ try
+ {
+ return new ConversionResult(Convert((VBasic.VisualBasicSyntaxNode)tree.GetRoot(), compilation.GetSemanticModel(tree, true), null).NormalizeWhitespace().ToFullString());
+ }
+ catch (Exception ex)
+ {
+ return new ConversionResult(ex);
+ }
+ }
+
+ static Dictionary SplitVariableDeclarations(VBSyntax.VariableDeclaratorSyntax declarator, NodesVisitor nodesVisitor, SemanticModel semanticModel)
+ {
+ var rawType = (TypeSyntax)declarator.AsClause?.TypeSwitch(
+ (VBSyntax.SimpleAsClauseSyntax c) => c.Type,
+ (VBSyntax.AsNewClauseSyntax c) => VBasic.SyntaxExtensions.Type(c.NewExpression),
+ _ => { throw new NotImplementedException($"{_.GetType().FullName} not implemented!"); }
+ )?.Accept(nodesVisitor) ?? SyntaxFactory.ParseTypeName("var");
+
+ var initializer = (ExpressionSyntax)declarator.AsClause?.TypeSwitch(
+ (VBSyntax.SimpleAsClauseSyntax _) => declarator.Initializer?.Value,
+ (VBSyntax.AsNewClauseSyntax c) => c.NewExpression
+ )?.Accept(nodesVisitor) ?? (ExpressionSyntax)declarator.Initializer?.Value.Accept(nodesVisitor);
+
+ var newDecls = new Dictionary();
+
+ foreach (var name in declarator.Names)
+ {
+ var type = rawType;
+ if (!name.Nullable.IsKind(VBasic.SyntaxKind.None))
+ {
+ if (type is ArrayTypeSyntax)
+ type = ((ArrayTypeSyntax)type).WithElementType(SyntaxFactory.NullableType(((ArrayTypeSyntax)type).ElementType));
+ else
+ type = SyntaxFactory.NullableType(type);
+ }
+ if (name.ArrayRankSpecifiers.Count > 0)
+ type = SyntaxFactory.ArrayType(type, SyntaxFactory.List(name.ArrayRankSpecifiers.Select(a => (ArrayRankSpecifierSyntax)a.Accept(nodesVisitor))));
+ VariableDeclarationSyntax decl;
+ var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier, semanticModel), null, initializer == null ? null : SyntaxFactory.EqualsValueClause(initializer));
+ string k = type.ToString();
+ if (newDecls.TryGetValue(k, out decl))
+ newDecls[k] = decl.AddVariables(v);
+ else
+ newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v));
+ }
+
+ return newDecls;
+ }
+
+ static ExpressionSyntax Literal(object o) => CodeRefactorings.ComputeConstantValueCodeRefactoringProvider.GetLiteralExpression(o);
+
+ static SyntaxToken ConvertIdentifier(SyntaxToken id, SemanticModel semanticModel, bool isInTypeContext = false)
+ {
+ var keywordKind = SyntaxFacts.GetKeywordKind(id.ValueText);
+ if (keywordKind != SyntaxKind.None && !SyntaxFacts.IsPredefinedType(keywordKind))
+ return SyntaxFactory.Identifier("@" + id.ValueText);
+ var symbol = semanticModel.GetSymbolInfo(id.Parent).Symbol;
+ string text = id.ValueText;
+ if (symbol != null && !string.IsNullOrWhiteSpace(symbol.Name))
+ text = symbol.Name;
+ return SyntaxFactory.Identifier(text);
+ }
+
+ static SyntaxTokenList ConvertModifiers(IEnumerable modifiers, TokenContext context = TokenContext.Global)
+ {
+ return SyntaxFactory.TokenList(ConvertModifiersCore(modifiers, context));
+ }
+
+ static SyntaxTokenList ConvertModifiers(SyntaxTokenList modifiers, TokenContext context = TokenContext.Global)
+ {
+ return SyntaxFactory.TokenList(ConvertModifiersCore(modifiers, context));
+ }
+
+ static SyntaxToken? ConvertModifier(SyntaxToken m, TokenContext context = TokenContext.Global)
+ {
+ var token = ConvertToken(VBasic.VisualBasicExtensions.Kind(m), context);
+ return token == SyntaxKind.None ? null : new SyntaxToken?(SyntaxFactory.Token(token));
+ }
+
+ static IEnumerable ConvertModifiersCore(IEnumerable modifiers, TokenContext context)
+ {
+ if (context != TokenContext.Local && context != TokenContext.InterfaceOrModule)
+ {
+ bool visibility = false;
+ foreach (var token in modifiers)
+ {
+ if (IsVisibility(token, context))
+ {
+ visibility = true;
+ break;
+ }
+ }
+ if (!visibility && context == TokenContext.Member)
+ yield return VisualBasicDefaultVisibility(context);
+ }
+ foreach (var token in modifiers.Where(m => !IgnoreInContext(m, context)))
+ {
+ var m = ConvertModifier(token, context);
+ if (m.HasValue) yield return m.Value;
+ }
+ }
+
+ static bool IgnoreInContext(SyntaxToken m, TokenContext context)
+ {
+ switch (VBasic.VisualBasicExtensions.Kind(m))
+ {
+ case VBasic.SyntaxKind.OptionalKeyword:
+ case VBasic.SyntaxKind.ByValKeyword:
+ case VBasic.SyntaxKind.IteratorKeyword:
+ case VBasic.SyntaxKind.DimKeyword:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ static bool IsVisibility(SyntaxToken token, TokenContext context)
+ {
+ return token.IsKind(VBasic.SyntaxKind.PublicKeyword, VBasic.SyntaxKind.FriendKeyword, VBasic.SyntaxKind.ProtectedKeyword, VBasic.SyntaxKind.PrivateKeyword)
+ || (context == TokenContext.VariableOrConst && token.IsKind(VBasic.SyntaxKind.ConstKeyword));
+ }
+
+ static SyntaxToken VisualBasicDefaultVisibility(TokenContext context)
+ {
+ switch (context)
+ {
+ case TokenContext.Global:
+ return SyntaxFactory.Token(SyntaxKind.InternalKeyword);
+ case TokenContext.Local:
+ case TokenContext.VariableOrConst:
+ case TokenContext.Member:
+ return SyntaxFactory.Token(SyntaxKind.PrivateKeyword);
+ }
+ throw new ArgumentOutOfRangeException(nameof(context));
+ }
+
+ static SyntaxToken ConvertToken(SyntaxToken t, TokenContext context = TokenContext.Global)
+ {
+ return SyntaxFactory.Token(ConvertToken(VBasic.VisualBasicExtensions.Kind(t), context));
+ }
+
+ static SyntaxKind ConvertToken(VBasic.SyntaxKind t, TokenContext context = TokenContext.Global)
+ {
+ switch (t)
+ {
+ case VBasic.SyntaxKind.None:
+ return SyntaxKind.None;
+ // built-in types
+ case VBasic.SyntaxKind.BooleanKeyword:
+ return SyntaxKind.BoolKeyword;
+ case VBasic.SyntaxKind.ByteKeyword:
+ return SyntaxKind.ByteKeyword;
+ case VBasic.SyntaxKind.SByteKeyword:
+ return SyntaxKind.SByteKeyword;
+ case VBasic.SyntaxKind.ShortKeyword:
+ return SyntaxKind.ShortKeyword;
+ case VBasic.SyntaxKind.UShortKeyword:
+ return SyntaxKind.UShortKeyword;
+ case VBasic.SyntaxKind.IntegerKeyword:
+ return SyntaxKind.IntKeyword;
+ case VBasic.SyntaxKind.UIntegerKeyword:
+ return SyntaxKind.UIntKeyword;
+ case VBasic.SyntaxKind.LongKeyword:
+ return SyntaxKind.LongKeyword;
+ case VBasic.SyntaxKind.ULongKeyword:
+ return SyntaxKind.ULongKeyword;
+ case VBasic.SyntaxKind.DoubleKeyword:
+ return SyntaxKind.DoubleKeyword;
+ case VBasic.SyntaxKind.SingleKeyword:
+ return SyntaxKind.FloatKeyword;
+ case VBasic.SyntaxKind.DecimalKeyword:
+ return SyntaxKind.DecimalKeyword;
+ case VBasic.SyntaxKind.StringKeyword:
+ return SyntaxKind.StringKeyword;
+ case VBasic.SyntaxKind.CharKeyword:
+ return SyntaxKind.CharKeyword;
+ case VBasic.SyntaxKind.ObjectKeyword:
+ return SyntaxKind.ObjectKeyword;
+ // literals
+ case VBasic.SyntaxKind.NothingKeyword:
+ return SyntaxKind.NullKeyword;
+ case VBasic.SyntaxKind.TrueKeyword:
+ return SyntaxKind.TrueKeyword;
+ case VBasic.SyntaxKind.FalseKeyword:
+ return SyntaxKind.FalseKeyword;
+ case VBasic.SyntaxKind.MeKeyword:
+ return SyntaxKind.ThisKeyword;
+ case VBasic.SyntaxKind.MyBaseKeyword:
+ return SyntaxKind.BaseKeyword;
+ // modifiers
+ case VBasic.SyntaxKind.PublicKeyword:
+ return SyntaxKind.PublicKeyword;
+ case VBasic.SyntaxKind.FriendKeyword:
+ return SyntaxKind.InternalKeyword;
+ case VBasic.SyntaxKind.ProtectedKeyword:
+ return SyntaxKind.ProtectedKeyword;
+ case VBasic.SyntaxKind.PrivateKeyword:
+ return SyntaxKind.PrivateKeyword;
+ case VBasic.SyntaxKind.ByRefKeyword:
+ return SyntaxKind.RefKeyword;
+ case VBasic.SyntaxKind.ParamArrayKeyword:
+ return SyntaxKind.ParamsKeyword;
+ case VBasic.SyntaxKind.ReadOnlyKeyword:
+ return SyntaxKind.ReadOnlyKeyword;
+ case VBasic.SyntaxKind.OverridesKeyword:
+ return SyntaxKind.OverrideKeyword;
+ case VBasic.SyntaxKind.SharedKeyword:
+ return SyntaxKind.StaticKeyword;
+ case VBasic.SyntaxKind.ConstKeyword:
+ return SyntaxKind.ConstKeyword;
+ case VBasic.SyntaxKind.PartialKeyword:
+ return SyntaxKind.PartialKeyword;
+ // unary operators
+ case VBasic.SyntaxKind.UnaryMinusExpression:
+ return SyntaxKind.UnaryMinusExpression;
+ case VBasic.SyntaxKind.UnaryPlusExpression:
+ return SyntaxKind.UnaryPlusExpression;
+ case VBasic.SyntaxKind.NotExpression:
+ return SyntaxKind.LogicalNotExpression;
+ // binary operators
+ case VBasic.SyntaxKind.ConcatenateExpression:
+ case VBasic.SyntaxKind.AddExpression:
+ return SyntaxKind.AddExpression;
+ case VBasic.SyntaxKind.SubtractExpression:
+ return SyntaxKind.SubtractExpression;
+ case VBasic.SyntaxKind.MultiplyExpression:
+ return SyntaxKind.MultiplyExpression;
+ case VBasic.SyntaxKind.DivideExpression:
+ return SyntaxKind.DivideExpression;
+ case VBasic.SyntaxKind.AndAlsoExpression:
+ return SyntaxKind.LogicalAndExpression;
+ case VBasic.SyntaxKind.OrElseExpression:
+ return SyntaxKind.LogicalOrExpression;
+ case VBasic.SyntaxKind.OrExpression:
+ return SyntaxKind.BitwiseOrExpression;
+ case VBasic.SyntaxKind.AndExpression:
+ return SyntaxKind.BitwiseAndExpression;
+ case VBasic.SyntaxKind.ExclusiveOrExpression:
+ return SyntaxKind.ExclusiveOrExpression;
+ case VBasic.SyntaxKind.EqualsExpression:
+ return SyntaxKind.EqualsExpression;
+ case VBasic.SyntaxKind.NotEqualsExpression:
+ return SyntaxKind.NotEqualsExpression;
+ case VBasic.SyntaxKind.GreaterThanExpression:
+ return SyntaxKind.GreaterThanExpression;
+ case VBasic.SyntaxKind.GreaterThanOrEqualExpression:
+ return SyntaxKind.GreaterThanOrEqualExpression;
+ case VBasic.SyntaxKind.LessThanExpression:
+ return SyntaxKind.LessThanExpression;
+ case VBasic.SyntaxKind.LessThanOrEqualExpression:
+ return SyntaxKind.LessThanOrEqualExpression;
+ // assignment
+ case VBasic.SyntaxKind.SimpleAssignmentStatement:
+ return SyntaxKind.SimpleAssignmentExpression;
+ case VBasic.SyntaxKind.AddAssignmentStatement:
+ return SyntaxKind.AddAssignmentExpression;
+ case VBasic.SyntaxKind.SubtractAssignmentStatement:
+ return SyntaxKind.SubtractAssignmentExpression;
+ case VBasic.SyntaxKind.MultiplyAssignmentStatement:
+ return SyntaxKind.MultiplyAssignmentExpression;
+ case VBasic.SyntaxKind.DivideAssignmentStatement:
+ return SyntaxKind.DivideAssignmentExpression;
+ // Casts
+ case VBasic.SyntaxKind.CObjKeyword:
+ return SyntaxKind.ObjectKeyword;
+ case VBasic.SyntaxKind.CBoolKeyword:
+ return SyntaxKind.BoolKeyword;
+ case VBasic.SyntaxKind.CCharKeyword:
+ return SyntaxKind.CharKeyword;
+ case VBasic.SyntaxKind.CSByteKeyword:
+ return SyntaxKind.SByteKeyword;
+ case VBasic.SyntaxKind.CByteKeyword:
+ return SyntaxKind.ByteKeyword;
+ case VBasic.SyntaxKind.CShortKeyword:
+ return SyntaxKind.ShortKeyword;
+ case VBasic.SyntaxKind.CUShortKeyword:
+ return SyntaxKind.UShortKeyword;
+ case VBasic.SyntaxKind.CIntKeyword:
+ return SyntaxKind.IntKeyword;
+ case VBasic.SyntaxKind.CUIntKeyword:
+ return SyntaxKind.UIntKeyword;
+ case VBasic.SyntaxKind.CLngKeyword:
+ return SyntaxKind.LongKeyword;
+ case VBasic.SyntaxKind.CULngKeyword:
+ return SyntaxKind.ULongKeyword;
+ case VBasic.SyntaxKind.CDecKeyword:
+ return SyntaxKind.DecimalKeyword;
+ case VBasic.SyntaxKind.CSngKeyword:
+ return SyntaxKind.FloatKeyword;
+ case VBasic.SyntaxKind.CDblKeyword:
+ return SyntaxKind.DoubleKeyword;
+ case VBasic.SyntaxKind.CStrKeyword:
+ return SyntaxKind.StringKeyword;
+ //
+ case VBasic.SyntaxKind.AssemblyKeyword:
+ return SyntaxKind.AssemblyKeyword;
+ }
+ throw new NotSupportedException(t + " not supported!");
+ }
+ }
+}
diff --git a/RefactoringEssentials/RefactoringEssentials.csproj b/RefactoringEssentials/RefactoringEssentials.csproj
index ef4a0fa2..54ff0fff 100644
--- a/RefactoringEssentials/RefactoringEssentials.csproj
+++ b/RefactoringEssentials/RefactoringEssentials.csproj
@@ -62,6 +62,9 @@
+
+
+
diff --git a/RefactoringEssentials/Util/CSharpUtil.cs b/RefactoringEssentials/Util/CSharpUtil.cs
index 032006f5..40757970 100644
--- a/RefactoringEssentials/Util/CSharpUtil.cs
+++ b/RefactoringEssentials/Util/CSharpUtil.cs
@@ -80,11 +80,66 @@ static ExpressionSyntax InvertConditionInternal(ExpressionSyntax condition)
return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, AddParensIfRequired(condition, false));
}
- ///
- /// When negating an expression this is required, otherwise you would end up with
- /// a or b -> !a or b
- ///
- public static ExpressionSyntax AddParensIfRequired(ExpressionSyntax expression, bool parenthesesRequiredForUnaryExpressions = true)
+
+ public static SyntaxKind GetExpressionOperatorTokenKind(SyntaxKind op)
+ {
+ switch (op)
+ {
+ case SyntaxKind.EqualsExpression:
+ return SyntaxKind.EqualsEqualsToken;
+ case SyntaxKind.NotEqualsExpression:
+ return SyntaxKind.ExclamationEqualsToken;
+ case SyntaxKind.GreaterThanExpression:
+ return SyntaxKind.GreaterThanToken;
+ case SyntaxKind.GreaterThanOrEqualExpression:
+ return SyntaxKind.GreaterThanEqualsToken;
+ case SyntaxKind.LessThanExpression:
+ return SyntaxKind.LessThanToken;
+ case SyntaxKind.LessThanOrEqualExpression:
+ return SyntaxKind.LessThanEqualsToken;
+ case SyntaxKind.BitwiseOrExpression:
+ return SyntaxKind.BarToken;
+ case SyntaxKind.LogicalOrExpression:
+ return SyntaxKind.BarBarToken;
+ case SyntaxKind.BitwiseAndExpression:
+ return SyntaxKind.AmpersandToken;
+ case SyntaxKind.LogicalAndExpression:
+ return SyntaxKind.AmpersandAmpersandToken;
+ case SyntaxKind.AddExpression:
+ return SyntaxKind.PlusToken;
+ case SyntaxKind.SubtractExpression:
+ return SyntaxKind.MinusToken;
+ case SyntaxKind.MultiplyExpression:
+ return SyntaxKind.AsteriskToken;
+ case SyntaxKind.DivideExpression:
+ return SyntaxKind.SlashToken;
+ case SyntaxKind.ModuloExpression:
+ return SyntaxKind.PercentToken;
+ // assignments
+ case SyntaxKind.SimpleAssignmentExpression:
+ return SyntaxKind.EqualsToken;
+ case SyntaxKind.AddAssignmentExpression:
+ return SyntaxKind.PlusEqualsToken;
+ case SyntaxKind.SubtractAssignmentExpression:
+ return SyntaxKind.MinusEqualsToken;
+ // unary
+ case SyntaxKind.UnaryPlusExpression:
+ return SyntaxKind.PlusToken;
+ case SyntaxKind.UnaryMinusExpression:
+ return SyntaxKind.MinusToken;
+ case SyntaxKind.LogicalNotExpression:
+ return SyntaxKind.ExclamationToken;
+ case SyntaxKind.BitwiseNotExpression:
+ return SyntaxKind.TildeToken;
+ }
+ throw new ArgumentOutOfRangeException(nameof(op));
+ }
+
+ ///
+ /// When negating an expression this is required, otherwise you would end up with
+ /// a or b -> !a or b
+ ///
+ public static ExpressionSyntax AddParensIfRequired(ExpressionSyntax expression, bool parenthesesRequiredForUnaryExpressions = true)
{
if ((expression is BinaryExpressionSyntax) ||
(expression is AssignmentExpressionSyntax) ||
From 00516df694256dcfb4c57046b7fb09ef6d89dbe3 Mon Sep 17 00:00:00 2001
From: Siegfried Pammer
Date: Fri, 30 Sep 2016 20:26:26 +0200
Subject: [PATCH 010/236] Add VB->C# option to web interface
---
.../Controllers/ConverterController.cs | 21 ++++++++++++-------
CodeConverterWebApp/Views/Home/Index.cshtml | 8 +++----
.../Converter/CodeConverter.cs | 15 ++++++++++---
.../Converter/ConversionResult.cs | 2 +-
4 files changed, 31 insertions(+), 15 deletions(-)
diff --git a/CodeConverterWebApp/Controllers/ConverterController.cs b/CodeConverterWebApp/Controllers/ConverterController.cs
index fb9c9af9..38306083 100644
--- a/CodeConverterWebApp/Controllers/ConverterController.cs
+++ b/CodeConverterWebApp/Controllers/ConverterController.cs
@@ -49,17 +49,24 @@ public IHttpActionResult Post([FromBody]ConvertRequest todo)
string ParseLanguage(string language)
{
- if ("cs".Equals(language, StringComparison.OrdinalIgnoreCase))
+ if (language == null)
+ throw new ArgumentNullException(nameof(language));
+ if (language.StartsWith("cs", StringComparison.OrdinalIgnoreCase))
return "C#";
- return "Visual Basic";
+ if (language.StartsWith("vb", StringComparison.OrdinalIgnoreCase))
+ return "Visual Basic";
+ throw new ArgumentException($"{language} not supported!");
}
int GetDefaultVersionForLanguage(string language)
{
- if ("cs".Equals(language, StringComparison.OrdinalIgnoreCase))
- return 6;
- // Visual Basic
- return 14;
- }
+ if (language == null)
+ throw new ArgumentNullException(nameof(language));
+ if (language.StartsWith("cs", StringComparison.OrdinalIgnoreCase))
+ return 6;
+ if (language.StartsWith("vb", StringComparison.OrdinalIgnoreCase))
+ return 14;
+ throw new ArgumentException($"{language} not supported!");
+ }
}
}
diff --git a/CodeConverterWebApp/Views/Home/Index.cshtml b/CodeConverterWebApp/Views/Home/Index.cshtml
index 9fe3b36b..3a24bbe0 100644
--- a/CodeConverterWebApp/Views/Home/Index.cshtml
+++ b/CodeConverterWebApp/Views/Home/Index.cshtml
@@ -20,10 +20,10 @@
C# to VB.NET
- @*
@@ -33,7 +33,7 @@
-
Error message: {{errorMessageOnResponse}}
+
Error message: {{errorMessageOnResponse}}
diff --git a/RefactoringEssentials/Converter/CodeConverter.cs b/RefactoringEssentials/Converter/CodeConverter.cs
index 9735faa4..3ddbcfec 100644
--- a/RefactoringEssentials/Converter/CodeConverter.cs
+++ b/RefactoringEssentials/Converter/CodeConverter.cs
@@ -1,5 +1,6 @@
using System;
using ConvVB = RefactoringEssentials.VB.Converter;
+using ConvCS = RefactoringEssentials.CSharp.Converter;
namespace RefactoringEssentials.Converter
{
@@ -23,18 +24,26 @@ public static ConversionResult Convert(CodeWithOptions code)
return ConvVB.CSharpConverter.ConvertText(code.Text, code.References);
}
break;
- }
+ case "Visual Basic":
+ switch (code.ToLanguage)
+ {
+ case "C#":
+ return ConvCS.VisualBasicConverter.ConvertText(code.Text, code.References);
+ }
+ break;
+
+ }
return new ConversionResult(new NotSupportedException($"Converting from {code.FromLanguage} {code.FromLanguageVersion} to {code.ToLanguage} {code.ToLanguageVersion} is not supported!"));
}
static bool IsSupportedTarget(string toLanguage, int toLanguageVersion)
{
- return toLanguage == "Visual Basic" && toLanguageVersion == 14;
+ return (toLanguage == "Visual Basic" && toLanguageVersion == 14) || (toLanguage == "C#" && toLanguageVersion == 6);
}
static bool IsSupportedSource(string fromLanguage, int fromLanguageVersion)
{
- return fromLanguage == "C#" && fromLanguageVersion == 6;
+ return (fromLanguage == "C#" && fromLanguageVersion == 6) || (fromLanguage == "Visual Basic" && fromLanguageVersion == 14);
}
}
}
diff --git a/RefactoringEssentials/Converter/ConversionResult.cs b/RefactoringEssentials/Converter/ConversionResult.cs
index aa7f84c4..0b9f166b 100644
--- a/RefactoringEssentials/Converter/ConversionResult.cs
+++ b/RefactoringEssentials/Converter/ConversionResult.cs
@@ -32,7 +32,7 @@ public string GetExceptionsAsString()
var builder = new StringBuilder();
for (int i = 0; i < Exceptions.Count; i++)
{
- builder.AppendFormat("----- Exception {0} of {1} -----\r\n", i + 1, Exceptions.Count);
+ builder.AppendFormat("----- Exception {0} of {1} -----" + Environment.NewLine, i + 1, Exceptions.Count);
builder.AppendLine(Exceptions[i].ToString());
}
return builder.ToString();
From 046cc852fa2e77f9bd99417ee3f2b487fdbc0fcb Mon Sep 17 00:00:00 2001
From: Siegfried Pammer
Date: Fri, 30 Sep 2016 20:27:06 +0200
Subject: [PATCH 011/236] Fix bug in C#->VB converter
---
.../VB/Converter/CSharpConverter.cs | 18 ++++----
.../VB/Converter/NodesVisitor.cs | 42 ++++++-------------
2 files changed, 22 insertions(+), 38 deletions(-)
diff --git a/RefactoringEssentials/VB/Converter/CSharpConverter.cs b/RefactoringEssentials/VB/Converter/CSharpConverter.cs
index e62e1bc9..926a5367 100644
--- a/RefactoringEssentials/VB/Converter/CSharpConverter.cs
+++ b/RefactoringEssentials/VB/Converter/CSharpConverter.cs
@@ -155,17 +155,17 @@ static ModifiedIdentifierSyntax ExtractIdentifier(CSS.VariableDeclaratorSyntax v
return SyntaxFactory.ModifiedIdentifier(ConvertIdentifier(v.Identifier));
}
- static SyntaxToken ConvertIdentifier(SyntaxToken t)
- {
- return SyntaxFactory.Identifier(t.ValueText, SyntaxFacts.IsKeywordKind(t.Kind()), t.GetIdentifierText(), TypeCharacter.None);
- }
+ static SyntaxToken ConvertIdentifier(SyntaxToken id)
+ {
+ var keywordKind = SyntaxFacts.GetKeywordKind(id.ValueText);
+ if (keywordKind != SyntaxKind.None && !SyntaxFacts.IsPredefinedType(keywordKind))
+ return SyntaxFactory.Identifier("[" + id.ValueText + "]");
+ return SyntaxFactory.Identifier(id.ValueText);
+ }
- static ExpressionSyntax Literal(object o)
- {
- return ComputeConstantValueCodeRefactoringProvider.GetLiteralExpression(o);
- }
+ static ExpressionSyntax Literal(object o) => ComputeConstantValueCodeRefactoringProvider.GetLiteralExpression(o);
- static SyntaxKind ConvertToken(CS.SyntaxKind t, TokenContext context = TokenContext.Global)
+ static SyntaxKind ConvertToken(CS.SyntaxKind t, TokenContext context = TokenContext.Global)
{
switch (t)
{
diff --git a/RefactoringEssentials/VB/Converter/NodesVisitor.cs b/RefactoringEssentials/VB/Converter/NodesVisitor.cs
index 5d7e4852..512f0d32 100644
--- a/RefactoringEssentials/VB/Converter/NodesVisitor.cs
+++ b/RefactoringEssentials/VB/Converter/NodesVisitor.cs
@@ -161,10 +161,6 @@ public override VisualBasicSyntaxNode VisitNamespaceDeclaration(CSS.NamespaceDec
@extern.Accept(this);
var members = node.Members.Select(m => (StatementSyntax)m.Accept(this));
- IList names;
- if (!node.Name.TryGetNameParts(out names))
- throw new NotSupportedException();
-
return SyntaxFactory.NamespaceBlock(
SyntaxFactory.NamespaceStatement((NameSyntax)node.Name.Accept(this)),
SyntaxFactory.List(members)
@@ -919,12 +915,12 @@ public override VisualBasicSyntaxNode VisitConditionalAccessExpression(CSS.Condi
public override VisualBasicSyntaxNode VisitMemberAccessExpression(CSS.MemberAccessExpressionSyntax node)
{
- return SyntaxFactory.MemberAccessExpression(
+ return WrapTypedNameIfNecessary(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
(ExpressionSyntax)node.Expression.Accept(this),
SyntaxFactory.Token(SyntaxKind.DotToken),
(SimpleNameSyntax)node.Name.Accept(this)
- );
+ ), node);
}
public override VisualBasicSyntaxNode VisitImplicitElementAccess(CSS.ImplicitElementAccessSyntax node)
@@ -1135,13 +1131,9 @@ public override VisualBasicSyntaxNode VisitImplicitArrayCreationExpression(CSS.I
ExpressionSyntax ReduceArrayUpperBoundExpression(ExpressionSyntax expr)
{
- if (expr.IsKind(SyntaxKind.NumericLiteralExpression))
- {
- var numericLiteral = expr as LiteralExpressionSyntax;
- int? upperBound = numericLiteral.Token.Value as int?;
- if (upperBound.HasValue)
- return SyntaxFactory.NumericLiteralExpression(SyntaxFactory.Literal(upperBound.Value - 1));
- }
+ var constant = semanticModel.GetConstantValue(expr);
+ if (constant.HasValue && constant.Value is int)
+ return SyntaxFactory.NumericLiteralExpression(SyntaxFactory.Literal((int)constant.Value - 1));
return SyntaxFactory.BinaryExpression(
SyntaxKind.SubtractExpression,
@@ -1428,7 +1420,7 @@ public override VisualBasicSyntaxNode VisitClassOrStructConstraint(CSS.ClassOrSt
public override VisualBasicSyntaxNode VisitTypeConstraint(CSS.TypeConstraintSyntax node)
{
- return SyntaxFactory.TypeConstraint((TypeSyntax)node.Accept(this));
+ return SyntaxFactory.TypeConstraint((TypeSyntax)node.Type.Accept(this));
}
public override VisualBasicSyntaxNode VisitConstructorConstraint(CSS.ConstructorConstraintSyntax node)
@@ -1504,14 +1496,6 @@ public override VisualBasicSyntaxNode VisitOmittedTypeArgument(CSS.OmittedTypeAr
#region NameSyntax
- SyntaxToken ConvertIdentifier(SyntaxToken id)
- {
- var keywordKind = SyntaxFacts.GetKeywordKind(id.ValueText);
- if (keywordKind != SyntaxKind.None && !SyntaxFacts.IsPredefinedType(keywordKind))
- return SyntaxFactory.Identifier("[" + id.ValueText + "]");
- return SyntaxFactory.Identifier(id.ValueText);
- }
-
public override VisualBasicSyntaxNode VisitIdentifierName(CSS.IdentifierNameSyntax node)
{
return WrapTypedNameIfNecessary(SyntaxFactory.IdentifierName(ConvertIdentifier(node.Identifier)), node);
@@ -1537,18 +1521,18 @@ public override VisualBasicSyntaxNode VisitTypeArgumentList(CSS.TypeArgumentList
return SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(node.Arguments.Select(a => (TypeSyntax)a.Accept(this))));
}
- VisualBasicSyntaxNode WrapTypedNameIfNecessary(NameSyntax name, CSS.NameSyntax originalName)
+ VisualBasicSyntaxNode WrapTypedNameIfNecessary(ExpressionSyntax name, CSS.ExpressionSyntax originalName)
{
- if (originalName.Parent is CSS.NameSyntax || originalName.Parent is CSS.AttributeSyntax) return name;
- CSS.ExpressionSyntax parent = originalName;
- while (parent.Parent is CSS.MemberAccessExpressionSyntax || parent.Parent is CSS.MemberBindingExpressionSyntax)
- parent = (CSS.ExpressionSyntax)parent.Parent;
- if (parent != null && parent.Parent is CSS.InvocationExpressionSyntax)
+ if (originalName.Parent is CSS.NameSyntax || originalName.Parent is CSS.AttributeSyntax || originalName.Parent is CSS.MemberAccessExpressionSyntax || originalName.Parent is CSS.MemberBindingExpressionSyntax) return name;
+ if (originalName != null && originalName.Parent is CSS.InvocationExpressionSyntax)
return name;
- var symbol = semanticModel.GetSymbolInfo(originalName).Symbol;
+ var symbolInfo = semanticModel.GetSymbolInfo(originalName);
+ var symbol = symbolInfo.Symbol ?? symbolInfo.CandidateSymbols.FirstOrDefault();
if (symbol.IsKind(SymbolKind.Method))
return SyntaxFactory.AddressOfExpression(name);
+
+
return name;
}
From 09a20bc6a9e6922e3f83fa3a4d0a11eb68f411b4 Mon Sep 17 00:00:00 2001
From: Siegfried Pammer
Date: Sun, 2 Oct 2016 18:39:47 +0200
Subject: [PATCH 012/236] implemented a few more expressions and missing
statements/constructs (see converter.txt for any missing items)
---
.../CSharp/Converter/MethodBodyVisitor.cs | 99 ++++++-
.../CSharp/Converter/NodesVisitor.cs | 244 +++++++++++++++---
.../CSharp/Converter/VisualBasicConverter.cs | 3 +
.../Util/SyntaxTokenExtensions.cs | 30 ++-
converter.txt | 14 +-
5 files changed, 342 insertions(+), 48 deletions(-)
diff --git a/RefactoringEssentials/CSharp/Converter/MethodBodyVisitor.cs b/RefactoringEssentials/CSharp/Converter/MethodBodyVisitor.cs
index 6c1ca2f7..53a26565 100644
--- a/RefactoringEssentials/CSharp/Converter/MethodBodyVisitor.cs
+++ b/RefactoringEssentials/CSharp/Converter/MethodBodyVisitor.cs
@@ -32,7 +32,7 @@ public override SyntaxList DefaultVisit(SyntaxNode node)
public override SyntaxList VisitLocalDeclarationStatement(VBSyntax.LocalDeclarationStatementSyntax node)
{
- var modifiers = ConvertModifiers(node.Modifiers);
+ var modifiers = ConvertModifiers(node.Modifiers, TokenContext.Local);
var declarations = new List();
@@ -69,6 +69,35 @@ public override SyntaxList VisitYieldStatement(VBSyntax.YieldSt
return SingleStatement(SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)node.Expression?.Accept(nodesVisitor)));
}
+ public override SyntaxList VisitExitStatement(VBSyntax.ExitStatementSyntax node)
+ {
+ switch (VBasic.VisualBasicExtensions.Kind(node.BlockKeyword))
+ {
+ case VBasic.SyntaxKind.SubKeyword:
+ return SingleStatement(SyntaxFactory.ReturnStatement());
+ case VBasic.SyntaxKind.FunctionKeyword:
+ VBasic.VisualBasicSyntaxNode typeContainer = (VBasic.VisualBasicSyntaxNode)node.Ancestors().OfType().FirstOrDefault()
+ ?? node.Ancestors().OfType().FirstOrDefault();
+ var info = typeContainer.TypeSwitch(
+ (VBSyntax.LambdaExpressionSyntax e) => semanticModel.GetTypeInfo(e).Type.GetReturnType(),
+ (VBSyntax.MethodBlockSyntax e) => {
+ var type = (TypeSyntax)e.SubOrFunctionStatement.AsClause?.Type.Accept(nodesVisitor) ?? SyntaxFactory.ParseTypeName("object");
+ return semanticModel.GetSymbolInfo(type).Symbol.GetReturnType();
+ }
+ );
+ ExpressionSyntax expr;
+ if (info.IsReferenceType)
+ expr = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
+ else if (info.CanBeReferencedByName)
+ expr = SyntaxFactory.DefaultExpression(SyntaxFactory.ParseTypeName(info.ToMinimalDisplayString(semanticModel, node.SpanStart)));
+ else
+ throw new NotSupportedException();
+ return SingleStatement(SyntaxFactory.ReturnStatement(expr));
+ default:
+ throw new NotImplementedException();
+ }
+ }
+
public override SyntaxList VisitSingleLineIfStatement(VBSyntax.SingleLineIfStatementSyntax node)
{
var condition = (ExpressionSyntax)node.Condition.Accept(nodesVisitor);
@@ -78,9 +107,9 @@ public override SyntaxList VisitSingleLineIfStatement(VBSyntax.
if (node.ElseClause != null)
{
var elseBlock = SyntaxFactory.Block(node.ElseClause.Statements.SelectMany(s => s.Accept(this)));
- elseClause = SyntaxFactory.ElseClause(elseBlock);
+ elseClause = SyntaxFactory.ElseClause(elseBlock.Statements.Count == 1 ? elseBlock.Statements[0] : elseBlock);
}
- return SingleStatement(SyntaxFactory.IfStatement(condition, block, elseClause));
+ return SingleStatement(SyntaxFactory.IfStatement(condition, block.Statements.Count == 1 ? block.Statements[0] : block, elseClause));
}
public override SyntaxList VisitMultiLineIfBlock(VBSyntax.MultiLineIfBlockSyntax node)
@@ -207,7 +236,14 @@ private bool ConvertToSwitch(ExpressionSyntax expr, SyntaxList VisitTryBlock(VBSyntax.TryBlockSyntax node)
{
- return base.VisitTryBlock(node);
+ var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)));
+ return SingleStatement(
+ SyntaxFactory.TryStatement(
+ block,
+ SyntaxFactory.List(node.CatchBlocks.Select(c => (CatchClauseSyntax)c.Accept(nodesVisitor))),
+ (FinallyClauseSyntax)node.FinallyBlock?.Accept(nodesVisitor)
+ )
+ );
}
public override SyntaxList VisitSyncLockBlock(VBSyntax.SyncLockBlockSyntax node)
@@ -218,6 +254,61 @@ public override SyntaxList VisitSyncLockBlock(VBSyntax.SyncLock
));
}
+ public override SyntaxList VisitUsingBlock(VBSyntax.UsingBlockSyntax node)
+ {
+ if (node.UsingStatement.Expression == null) {
+ StatementSyntax stmt = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)));
+ foreach (var v in node.UsingStatement.Variables.Reverse())
+ foreach (var declaration in SplitVariableDeclarations(v, nodesVisitor, semanticModel).Values.Reverse())
+ stmt = SyntaxFactory.UsingStatement(declaration, null, stmt);
+ return SingleStatement(stmt);
+ } else {
+ var expr = (ExpressionSyntax)node.UsingStatement.Expression.Accept(nodesVisitor);
+ return SingleStatement(SyntaxFactory.UsingStatement(null, expr, SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)))));
+ }
+ }
+
+ public override SyntaxList VisitWhileBlock(VBSyntax.WhileBlockSyntax node)
+ {
+ return SingleStatement(SyntaxFactory.WhileStatement(
+ (ExpressionSyntax)node.WhileStatement.Condition.Accept(nodesVisitor),
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)))
+ ));
+ }
+
+ public override SyntaxList VisitDoLoopBlock(VBSyntax.DoLoopBlockSyntax node)
+ {
+ if (node.DoStatement.WhileOrUntilClause != null)
+ {
+ var stmt = node.DoStatement.WhileOrUntilClause;
+ if (stmt.WhileOrUntilKeyword.IsKind(VBasic.SyntaxKind.WhileKeyword))
+ return SingleStatement(SyntaxFactory.WhileStatement(
+ (ExpressionSyntax)stmt.Condition.Accept(nodesVisitor),
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)))
+ ));
+ else
+ return SingleStatement(SyntaxFactory.WhileStatement(
+ SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, (ExpressionSyntax)stmt.Condition.Accept(nodesVisitor)),
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this)))
+ ));
+ }
+ if (node.LoopStatement.WhileOrUntilClause != null)
+ {
+ var stmt = node.LoopStatement.WhileOrUntilClause;
+ if (stmt.WhileOrUntilKeyword.IsKind(VBasic.SyntaxKind.WhileKeyword))
+ return SingleStatement(SyntaxFactory.DoStatement(
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this))),
+ (ExpressionSyntax)stmt.Condition.Accept(nodesVisitor)
+ ));
+ else
+ return SingleStatement(SyntaxFactory.DoStatement(
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(this))),
+ SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, (ExpressionSyntax)stmt.Condition.Accept(nodesVisitor))
+ ));
+ }
+ throw new NotSupportedException();
+ }
+
SyntaxList SingleStatement(StatementSyntax statement)
{
return SyntaxFactory.SingletonList(statement);
diff --git a/RefactoringEssentials/CSharp/Converter/NodesVisitor.cs b/RefactoringEssentials/CSharp/Converter/NodesVisitor.cs
index 518ec574..cd15749a 100644
--- a/RefactoringEssentials/CSharp/Converter/NodesVisitor.cs
+++ b/RefactoringEssentials/CSharp/Converter/NodesVisitor.cs
@@ -19,7 +19,7 @@ class NodesVisitor : VBasic.VisualBasicSyntaxVisitor
SemanticModel semanticModel;
Document targetDocument;
CSharpCompilationOptions options;
- readonly Dictionary additionalFieldDeclarations = new Dictionary();
+ readonly Dictionary additionalDeclarations = new Dictionary();
public NodesVisitor(SemanticModel semanticModel, Document targetDocument)
{
@@ -55,9 +55,11 @@ public override CSharpSyntaxNode VisitCompilationUnit(VBSyntax.CompilationUnitSy
var attributes = SyntaxFactory.List(node.Attributes.SelectMany(a => a.AttributeLists).SelectMany(ConvertAttribute));
var members = SyntaxFactory.List(node.Members.Select(m => (MemberDeclarationSyntax)m.Accept(this)));
+ var options = (VBasic.VisualBasicCompilationOptions)semanticModel.Compilation.Options;
+
return SyntaxFactory.CompilationUnit(
SyntaxFactory.List(),
- SyntaxFactory.List(node.Imports.SelectMany(imp => imp.ImportsClauses).Select(c => (UsingDirectiveSyntax)c.Accept(this))),
+ SyntaxFactory.List(options.GlobalImports.Select(gi => gi.Clause).Concat(node.Imports.SelectMany(imp => imp.ImportsClauses)).Select(c => (UsingDirectiveSyntax)c.Accept(this))),
attributes,
members
);
@@ -90,12 +92,12 @@ IEnumerable ConvertMembers(SyntaxList (MemberDeclarationSyntax)m.Accept(this)))
{
- BaseFieldDeclarationSyntax[] declarations;
- if (member is BaseFieldDeclarationSyntax && additionalFieldDeclarations.TryGetValue((BaseFieldDeclarationSyntax)member, out declarations))
+ MemberDeclarationSyntax[] declarations;
+ if (member is BaseFieldDeclarationSyntax && additionalDeclarations.TryGetValue(member, out declarations))
{
foreach (var d in declarations)
yield return d;
- additionalFieldDeclarations.Remove((BaseFieldDeclarationSyntax)member);
+ additionalDeclarations.Remove(member);
}
else
{
@@ -147,7 +149,7 @@ public override CSharpSyntaxNode VisitModuleBlock(VBSyntax.ModuleBlockSyntax nod
return SyntaxFactory.ClassDeclaration(
attributes,
- ConvertModifiers(stmt.Modifiers).Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)),
+ ConvertModifiers(stmt.Modifiers, TokenContext.InterfaceOrModule).Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)),
ConvertIdentifier(stmt.Identifier, semanticModel),
parameters,
ConvertInheritsAndImplements(node.Inherits, node.Implements),
@@ -168,7 +170,7 @@ public override CSharpSyntaxNode VisitStructureBlock(VBSyntax.StructureBlockSynt
return SyntaxFactory.StructDeclaration(
attributes,
- ConvertModifiers(stmt.Modifiers),
+ ConvertModifiers(stmt.Modifiers, TokenContext.Global),
ConvertIdentifier(stmt.Identifier, semanticModel),
parameters,
ConvertInheritsAndImplements(node.Inherits, node.Implements),
@@ -189,7 +191,7 @@ public override CSharpSyntaxNode VisitInterfaceBlock(VBSyntax.InterfaceBlockSynt
return SyntaxFactory.InterfaceDeclaration(
attributes,
- ConvertModifiers(stmt.Modifiers),
+ ConvertModifiers(stmt.Modifiers, TokenContext.InterfaceOrModule),
ConvertIdentifier(stmt.Identifier, semanticModel),
parameters,
ConvertInheritsAndImplements(node.Inherits, node.Implements),
@@ -221,7 +223,7 @@ public override CSharpSyntaxNode VisitEnumBlock(VBSyntax.EnumBlockSyntax node)
var members = SyntaxFactory.SeparatedList(node.Members.Select(m => (EnumMemberDeclarationSyntax)m.Accept(this)));
return SyntaxFactory.EnumDeclaration(
SyntaxFactory.List(attributes),
- ConvertModifiers(stmt.Modifiers),
+ ConvertModifiers(stmt.Modifiers, TokenContext.Global),
ConvertIdentifier(stmt.Identifier, semanticModel),
baseList,
members
@@ -268,7 +270,7 @@ public override CSharpSyntaxNode VisitDelegateStatement(VBSyntax.DelegateStateme
return SyntaxFactory.DelegateDeclaration(
SyntaxFactory.List(attributes),
- ConvertModifiers(node.Modifiers),
+ ConvertModifiers(node.Modifiers, TokenContext.Global),
returnType,
ConvertIdentifier(node.Identifier, semanticModel),
typeParameters,
@@ -284,7 +286,7 @@ public override CSharpSyntaxNode VisitDelegateStatement(VBSyntax.DelegateStateme
public override CSharpSyntaxNode VisitFieldDeclaration(VBSyntax.FieldDeclarationSyntax node)
{
var attributes = node.AttributeLists.SelectMany(ConvertAttribute);
- var modifiers = ConvertModifiers(node.Modifiers);
+ var modifiers = ConvertModifiers(node.Modifiers, TokenContext.VariableOrConst);
var key = SyntaxFactory.FieldDeclaration(SyntaxFactory.VariableDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword))));
var declarations = new List(node.Declarators.Count);
@@ -300,50 +302,170 @@ public override CSharpSyntaxNode VisitFieldDeclaration(VBSyntax.FieldDeclaration
}
}
- additionalFieldDeclarations.Add(key, declarations.ToArray());
+ additionalDeclarations.Add(key, declarations.ToArray());
return key;
}
public override CSharpSyntaxNode VisitPropertyBlock(VBSyntax.PropertyBlockSyntax node)
{
- return base.VisitPropertyBlock(node);
+ var block = node.PropertyStatement;
+ var attributes = block.AttributeLists.SelectMany(ConvertAttribute);
+ var modifiers = ConvertModifiers(block.Modifiers, TokenContext.Member);
+
+ var isIndexer = block.Modifiers.Any(m => m.IsKind(VBasic.SyntaxKind.DefaultKeyword)) && block.Identifier.ValueText.Equals("Items", StringComparison.OrdinalIgnoreCase);
+
+ var rawType = (TypeSyntax)block.AsClause?.TypeSwitch(
+ (VBSyntax.SimpleAsClauseSyntax c) => c.Type,
+ (VBSyntax.AsNewClauseSyntax c) => VBasic.SyntaxExtensions.Type(c.NewExpression),
+ _ => { throw new NotImplementedException($"{_.GetType().FullName} not implemented!"); }
+ )?.Accept(this) ?? SyntaxFactory.ParseTypeName("var");
+
+ if (isIndexer)
+ return SyntaxFactory.IndexerDeclaration(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ rawType,
+ null,
+ SyntaxFactory.BracketedParameterList(SyntaxFactory.SeparatedList(block.ParameterList.Parameters.Select(p => (ParameterSyntax)p.Accept(this)))),
+ SyntaxFactory.AccessorList(SyntaxFactory.List(node.Accessors.Select(a => (AccessorDeclarationSyntax)a.Accept(this))))
+ );
+ else
+ return SyntaxFactory.PropertyDeclaration(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ rawType,
+ null,
+ ConvertIdentifier(block.Identifier, semanticModel),
+ SyntaxFactory.AccessorList(SyntaxFactory.List(node.Accessors.Select(a => (AccessorDeclarationSyntax)a.Accept(this)))),
+ null,
+ null);
+ }
+
+ public override CSharpSyntaxNode VisitAccessorBlock(VBSyntax.AccessorBlockSyntax node)
+ {
+ SyntaxKind blockKind;
+ var body = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this))));
+ var attributes = SyntaxFactory.List(node.AccessorStatement.AttributeLists.Select(a => (AttributeListSyntax)a.Accept(this)));
+ var modifiers = ConvertModifiers(node.AccessorStatement.Modifiers, TokenContext.Member);
+
+ switch (node.Kind())
+ {
+ case VBasic.SyntaxKind.GetAccessorBlock:
+ blockKind = SyntaxKind.GetAccessorDeclaration;
+ break;
+ case VBasic.SyntaxKind.SetAccessorBlock:
+ blockKind = SyntaxKind.SetAccessorDeclaration;
+ break;
+ case VBasic.SyntaxKind.AddHandlerAccessorBlock:
+ blockKind = SyntaxKind.AddAccessorDeclaration;
+ break;
+ case VBasic.SyntaxKind.RemoveHandlerAccessorBlock:
+ blockKind = SyntaxKind.RemoveAccessorDeclaration;
+ break;
+ default:
+ throw new NotSupportedException();
+ }
+ return SyntaxFactory.AccessorDeclaration(blockKind, attributes, modifiers, body);
}
public override CSharpSyntaxNode VisitMethodBlock(VBSyntax.MethodBlockSyntax node)
{
var block = node.SubOrFunctionStatement;
var attributes = block.AttributeLists.SelectMany(ConvertAttribute);
- var modifiers = ConvertModifiers(block.Modifiers);
-
- return SyntaxFactory.MethodDeclaration(
+
+ if ("Finalize".Equals(block.Identifier.ValueText, StringComparison.OrdinalIgnoreCase)
+ && block.Modifiers.Any(m => VBasic.VisualBasicExtensions.Kind(m) == VBasic.SyntaxKind.OverridesKeyword)) {
+ return SyntaxFactory.DestructorDeclaration(
+ SyntaxFactory.List(attributes),
+ SyntaxFactory.TokenList(),
+ ConvertIdentifier(node.GetAncestor().BlockStatement.Identifier, semanticModel),
+ SyntaxFactory.ParameterList(),
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this))))
+ );
+ } else {
+ var modifiers = ConvertModifiers(block.Modifiers, TokenContext.Member);
+
+ return SyntaxFactory.MethodDeclaration(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ (TypeSyntax)block.AsClause?.Type.Accept(this) ?? SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)),
+ null,
+ ConvertIdentifier(block.Identifier, semanticModel),
+ null,
+ (ParameterListSyntax)block.ParameterList.Accept(this),
+ SyntaxFactory.List(),
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this)))),
+ null
+ );
+ }
+ }
+
+ public override CSharpSyntaxNode VisitEventBlock(VBSyntax.EventBlockSyntax node)
+ {
+ var block = node.EventStatement;
+ var attributes = block.AttributeLists.SelectMany(ConvertAttribute);
+ var modifiers = ConvertModifiers(block.Modifiers, TokenContext.Member);
+
+ var rawType = (TypeSyntax)block.AsClause?.Type.Accept(this) ?? SyntaxFactory.ParseTypeName("var");
+
+ return SyntaxFactory.EventDeclaration(
SyntaxFactory.List(attributes),
modifiers,
- (TypeSyntax)block.AsClause?.Type.Accept(this) ?? SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)),
+ rawType,
null,
ConvertIdentifier(block.Identifier, semanticModel),
- null,
- (ParameterListSyntax)block.ParameterList.Accept(this),
- SyntaxFactory.List(),
- SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this)))),
- null
+ SyntaxFactory.AccessorList(SyntaxFactory.List(node.Accessors.Select(a => (AccessorDeclarationSyntax)a.Accept(this))))
);
}
- public override CSharpSyntaxNode VisitEventBlock(VBSyntax.EventBlockSyntax node)
- {
- return base.VisitEventBlock(node);
- }
-
public override CSharpSyntaxNode VisitEventStatement(VBSyntax.EventStatementSyntax node)
{
- return base.VisitEventStatement(node);
+ var attributes = node.AttributeLists.SelectMany(ConvertAttribute);
+ var modifiers = ConvertModifiers(node.Modifiers, TokenContext.Member);
+ var id = ConvertIdentifier(node.Identifier, semanticModel);
+
+ if (node.AsClause == null)
+ {
+ var key = SyntaxFactory.EventFieldDeclaration(SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName("__event" + id.ValueText)));
+ var delegateName = SyntaxFactory.Identifier(id.ValueText + "EventHandler");
+
+ var delegateDecl = SyntaxFactory.DelegateDeclaration(
+ SyntaxFactory.List(),
+ modifiers,
+ SyntaxFactory.ParseTypeName("void"),
+ delegateName,
+ null,
+ (ParameterListSyntax)node.ParameterList.Accept(this),
+ SyntaxFactory.List()
+ );
+
+ var eventDecl = SyntaxFactory.EventFieldDeclaration(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(delegateName),
+ SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(id)))
+ );
+
+ additionalDeclarations.Add(key, new MemberDeclarationSyntax[] { eventDecl, delegateDecl });
+ return key;
+ }
+ else
+ {
+ return SyntaxFactory.EventFieldDeclaration(
+ SyntaxFactory.List(attributes),
+ modifiers,
+ SyntaxFactory.VariableDeclaration((TypeSyntax)node.AsClause.Type.Accept(this),
+ SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(id)))
+ );
+ }
+ throw new NotSupportedException();
}
public override CSharpSyntaxNode VisitOperatorBlock(VBSyntax.OperatorBlockSyntax node)
{
var block = node.OperatorStatement;
var attributes = block.AttributeLists.SelectMany(ConvertAttribute);
- var modifiers = ConvertModifiers(block.Modifiers);
+ var modifiers = ConvertModifiers(block.Modifiers, TokenContext.Member);
return SyntaxFactory.OperatorDeclaration(
SyntaxFactory.List(attributes),
modifiers,
@@ -359,14 +481,36 @@ public override CSharpSyntaxNode VisitConstructorBlock(VBSyntax.ConstructorBlock
{
var block = node.BlockStatement;
var attributes = block.AttributeLists.SelectMany(ConvertAttribute);
- var modifiers = ConvertModifiers(block.Modifiers);
+ var modifiers = ConvertModifiers(block.Modifiers, TokenContext.Member);
+
+
+ var ctor = (node.Statements.FirstOrDefault() as VBSyntax.ExpressionStatementSyntax)?.Expression as VBSyntax.InvocationExpressionSyntax;
+ var ctorExpression = ctor?.Expression as VBSyntax.MemberAccessExpressionSyntax;
+ var ctorArgs = (ArgumentListSyntax)ctor?.ArgumentList.Accept(this);
+
+ IEnumerable statements;
+ ConstructorInitializerSyntax ctorCall;
+ if (ctorExpression == null || !ctorExpression.Name.Identifier.IsKindOrHasMatchingText(VBasic.SyntaxKind.NewKeyword)) {
+ statements = node.Statements;
+ ctorCall = null;
+ } else if (ctorExpression.Expression is VBSyntax.MyBaseExpressionSyntax) {
+ statements = node.Statements.Skip(1);
+ ctorCall = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, ctorArgs ?? SyntaxFactory.ArgumentList());
+ } else if (ctorExpression.Expression is VBSyntax.MeExpressionSyntax || ctorExpression.Expression is VBSyntax.MyClassExpressionSyntax) {
+ statements = node.Statements.Skip(1);
+ ctorCall = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, ctorArgs ?? SyntaxFactory.ArgumentList());
+ } else {
+ statements = node.Statements;
+ ctorCall = null;
+ }
+
return SyntaxFactory.ConstructorDeclaration(
SyntaxFactory.List(attributes),
modifiers,
ConvertIdentifier(node.GetAncestor().BlockStatement.Identifier, semanticModel),
(ParameterListSyntax)block.ParameterList.Accept(this),
- null,
- SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this))))
+ ctorCall,
+ SyntaxFactory.Block(statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this))))
);
}
@@ -402,7 +546,7 @@ public override CSharpSyntaxNode VisitParameter(VBSyntax.ParameterSyntax node)
}
var attributes = node.AttributeLists.SelectMany(ConvertAttribute).ToList();
int outAttributeIndex = attributes.FindIndex(a => a.Attributes.Single().Name.ToString() == "Out");
- var modifiers = ConvertModifiers(node.Modifiers);
+ var modifiers = ConvertModifiers(node.Modifiers, TokenContext.Local);
if (outAttributeIndex > -1) {
attributes.RemoveAt(outAttributeIndex);
modifiers = modifiers.Replace(SyntaxFactory.Token(SyntaxKind.RefKeyword), SyntaxFactory.Token(SyntaxKind.OutKeyword));
@@ -420,6 +564,40 @@ public override CSharpSyntaxNode VisitParameter(VBSyntax.ParameterSyntax node)
#region Expressions
+ public override CSharpSyntaxNode VisitCatchBlock(VBSyntax.CatchBlockSyntax node)
+ {
+ var stmt = node.CatchStatement;
+ CatchDeclarationSyntax catcher;
+ if (stmt.IdentifierName == null)
+ catcher = null;
+ else
+ {
+ var typeInfo = semanticModel.GetTypeInfo(stmt.IdentifierName).Type;
+ catcher = SyntaxFactory.CatchDeclaration(
+ SyntaxFactory.ParseTypeName(typeInfo.ToMinimalDisplayString(semanticModel, node.SpanStart)),
+ ConvertIdentifier(stmt.IdentifierName.Identifier, semanticModel)
+ );
+ }
+
+ var filter = (CatchFilterClauseSyntax)stmt.WhenClause?.Accept(this);
+
+ return SyntaxFactory.CatchClause(
+ catcher,
+ filter,
+ SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this))))
+ );
+ }
+
+ public override CSharpSyntaxNode VisitCatchFilterClause(VBSyntax.CatchFilterClauseSyntax node)
+ {
+ return SyntaxFactory.CatchFilterClause((ExpressionSyntax)node.Filter.Accept(this));
+ }
+
+ public override CSharpSyntaxNode VisitFinallyBlock(VBSyntax.FinallyBlockSyntax node)
+ {
+ return SyntaxFactory.FinallyClause(SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(new MethodBodyVisitor(semanticModel, this)))));
+ }
+
public override CSharpSyntaxNode VisitCTypeExpression(VBSyntax.CTypeExpressionSyntax node)
{
return SyntaxFactory.CastExpression(
diff --git a/RefactoringEssentials/CSharp/Converter/VisualBasicConverter.cs b/RefactoringEssentials/CSharp/Converter/VisualBasicConverter.cs
index 18f0a855..087af0cc 100644
--- a/RefactoringEssentials/CSharp/Converter/VisualBasicConverter.cs
+++ b/RefactoringEssentials/CSharp/Converter/VisualBasicConverter.cs
@@ -149,6 +149,9 @@ static bool IgnoreInContext(SyntaxToken m, TokenContext context)
case VBasic.SyntaxKind.IteratorKeyword:
case VBasic.SyntaxKind.DimKeyword:
return true;
+ case VBasic.SyntaxKind.ReadOnlyKeyword:
+ case VBasic.SyntaxKind.WriteOnlyKeyword:
+ return context == TokenContext.Member;
default:
return false;
}
diff --git a/RefactoringEssentials/Util/SyntaxTokenExtensions.cs b/RefactoringEssentials/Util/SyntaxTokenExtensions.cs
index 098d24b6..ef6209b5 100644
--- a/RefactoringEssentials/Util/SyntaxTokenExtensions.cs
+++ b/RefactoringEssentials/Util/SyntaxTokenExtensions.cs
@@ -756,19 +756,29 @@ public static bool IsMandatoryNamedParameterPosition(this SyntaxToken token)
}
return false;
- }
+ }
- public static bool IsKindOrHasMatchingText(this SyntaxToken token, SyntaxKind kind)
- {
- return token.Kind() == kind || token.HasMatchingText(kind);
- }
+ public static bool IsKindOrHasMatchingText(this SyntaxToken token, SyntaxKind kind)
+ {
+ return token.Kind() == kind || token.HasMatchingText(kind);
+ }
- public static bool HasMatchingText(this SyntaxToken token, SyntaxKind kind)
- {
- return token.ToString() == SyntaxFacts.GetText(kind);
- }
+ public static bool IsKindOrHasMatchingText(this SyntaxToken token, Microsoft.CodeAnalysis.VisualBasic.SyntaxKind kind)
+ {
+ return Microsoft.CodeAnalysis.VisualBasic.VisualBasicExtensions.Kind(token) == kind || token.HasMatchingText(kind);
+ }
+
+ public static bool HasMatchingText(this SyntaxToken token, SyntaxKind kind)
+ {
+ return token.ToString() == SyntaxFacts.GetText(kind);
+ }
+
+ public static bool HasMatchingText(this SyntaxToken token, Microsoft.CodeAnalysis.VisualBasic.SyntaxKind kind)
+ {
+ return token.ToString() == Microsoft.CodeAnalysis.VisualBasic.SyntaxFacts.GetText(kind);
+ }
- public static bool IsKind(this SyntaxToken token, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind1, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind2)
+ public static bool IsKind(this SyntaxToken token, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind1, Microsoft.CodeAnalysis.CSharp.SyntaxKind kind2)
{
return Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(token) == kind1
|| Microsoft.CodeAnalysis.CSharp.CSharpExtensions.Kind(token) == kind2;
diff --git a/converter.txt b/converter.txt
index b0918b60..18e2bff5 100644
--- a/converter.txt
+++ b/converter.txt
@@ -12,4 +12,16 @@ C# to VB:
- unsafe code cannot be converted
VB to C#:
-- not implemented
+- statements:
+ * special select case expressions
+ * special statements: call, erase, redim, a.o.
+- expressions:
+ * .. To .. arguments
+ * anonymous types
+- special cases:
+ * Should add Public Modifier to inner types, methods, properties and fields in structures
+ * Built-in methods => Prefix with class name
+ * Function A() \n A = SomeValue \n End Function -> convert to return statement
+ * Comparison with empty string literal -> string.IsNullOrEmpty
+ * Add default value to local variable declarations without initializer
+ * XML literals -> XLinq
\ No newline at end of file
From d137c4af6c543a4ffd5c5ded5e8bc1d264b78eeb Mon Sep 17 00:00:00 2001
From: Siegfried Pammer
Date: Sun, 2 Oct 2016 19:02:00 +0200
Subject: [PATCH 013/236] fix bug in C#->VB converter
---
RefactoringEssentials/VB/Converter/NodesVisitor.cs | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/RefactoringEssentials/VB/Converter/NodesVisitor.cs b/RefactoringEssentials/VB/Converter/NodesVisitor.cs
index 512f0d32..77cdeac2 100644
--- a/RefactoringEssentials/VB/Converter/NodesVisitor.cs
+++ b/RefactoringEssentials/VB/Converter/NodesVisitor.cs
@@ -1109,7 +1109,7 @@ public override VisualBasicSyntaxNode VisitAnonymousObjectMemberDeclarator(CSS.A
public override VisualBasicSyntaxNode VisitArrayCreationExpression(CSS.ArrayCreationExpressionSyntax node)
{
var upperBoundArguments = node.Type.RankSpecifiers.First()?.Sizes.Where(s => !(s is CSS.OmittedArraySizeExpressionSyntax)).Select(
- s => (ArgumentSyntax) SyntaxFactory.SimpleArgument(ReduceArrayUpperBoundExpression((ExpressionSyntax)s.Accept(this))));
+ s => (ArgumentSyntax) SyntaxFactory.SimpleArgument(ReduceArrayUpperBoundExpression(s)));
var rankSpecifiers = node.Type.RankSpecifiers.Select(rs => (ArrayRankSpecifierSyntax)rs.Accept(this));
return SyntaxFactory.ArrayCreationExpression(
@@ -1129,7 +1129,7 @@ public override VisualBasicSyntaxNode VisitImplicitArrayCreationExpression(CSS.I
);
}
- ExpressionSyntax ReduceArrayUpperBoundExpression(ExpressionSyntax expr)
+ ExpressionSyntax ReduceArrayUpperBoundExpression(CSS.ExpressionSyntax expr)
{
var constant = semanticModel.GetConstantValue(expr);
if (constant.HasValue && constant.Value is int)
@@ -1137,7 +1137,7 @@ ExpressionSyntax ReduceArrayUpperBoundExpression(ExpressionSyntax expr)
return SyntaxFactory.BinaryExpression(
SyntaxKind.SubtractExpression,
- expr, SyntaxFactory.Token(SyntaxKind.MinusToken), SyntaxFactory.NumericLiteralExpression(SyntaxFactory.Literal(1)));
+ (ExpressionSyntax)expr.Accept(this), SyntaxFactory.Token(SyntaxKind.MinusToken), SyntaxFactory.NumericLiteralExpression(SyntaxFactory.Literal(1)));
}
public override VisualBasicSyntaxNode VisitInitializerExpression(CSS.InitializerExpressionSyntax node)
From 5ab73276453b60c9557892c12cb3bb7b1e4e7124 Mon Sep 17 00:00:00 2001
From: Andreas Weizel
Date: Sun, 2 Oct 2016 21:33:36 +0200
Subject: [PATCH 014/236] Added context menu commands for new VB -> C#
converter in code editor and Solution Explorer.
---
Vsix/CodeConversion.cs | 97 ++++++++--
Vsix/ConvertCSToVBCommand.cs | 6 +-
Vsix/ConvertVBToCSCommand.cs | 167 ++++++++++++++++++
...ommandPackage.cs => REConverterPackage.cs} | 9 +-
...ndPackage.vsct => REConverterPackage.vsct} | 34 +++-
Vsix/VSPackage.resx | 69 +++-----
Vsix/Vsix.csproj | 5 +-
7 files changed, 325 insertions(+), 62 deletions(-)
create mode 100644 Vsix/ConvertVBToCSCommand.cs
rename Vsix/{ConvertCSToVBCommandPackage.cs => REConverterPackage.cs} (93%)
rename Vsix/{ConvertCSToVBCommandPackage.vsct => REConverterPackage.vsct} (62%)
diff --git a/Vsix/CodeConversion.cs b/Vsix/CodeConversion.cs
index 76feefbf..d0a02c04 100644
--- a/Vsix/CodeConversion.cs
+++ b/Vsix/CodeConversion.cs
@@ -15,23 +15,28 @@ namespace RefactoringEssentials.VsExtension
static class CodeConversion
{
public static readonly string CSToVBConversionTitle = "Convert C# to VB:";
+ public static readonly string VBToCSConversionTitle = "Convert VB to C#:";
public static void PerformCSToVBConversion(IServiceProvider serviceProvider, string inputCode)
{
string convertedText = null;
try
{
- if (!TryConvertingCSToVBCode(inputCode, out convertedText))
+ var result = TryConvertingCSToVBCode(inputCode);
+ if (!result.Success)
{
+ var newLines = Environment.NewLine + Environment.NewLine;
VsShellUtilities.ShowMessageBox(
serviceProvider,
- "Selected C# code seems to have errors or to be incomplete.",
+ $"Selected C# code seems to have errors or to be incomplete:{newLines}{result.GetExceptionsAsString()}",
CSToVBConversionTitle,
OLEMSGICON.OLEMSGICON_WARNING,
OLEMSGBUTTON.OLEMSGBUTTON_OK,
OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
return;
}
+
+ convertedText = result.ConvertedCode;
}
catch (Exception ex)
{
@@ -54,21 +59,64 @@ public static void PerformCSToVBConversion(IServiceProvider serviceProvider, str
Clipboard.SetText(convertedText);
}
- static bool TryConvertingCSToVBCode(string csCode, out string vbCode)
+ static ConversionResult TryConvertingCSToVBCode(string inputCode)
{
- vbCode = null;
-
- var codeWithOptions = new CodeWithOptions(csCode)
+ var codeWithOptions = new CodeWithOptions(inputCode)
+ .SetFromLanguage("C#")
+ .SetToLanguage("Visual Basic")
.WithDefaultReferences();
- var result = CodeConverter.Convert(codeWithOptions);
+ return CodeConverter.Convert(codeWithOptions);
+ }
+
+ public static void PerformVBToCSConversion(IServiceProvider serviceProvider, string inputCode)
+ {
+ string convertedText = null;
+ try
+ {
+ var result = TryConvertingVBToCSCode(inputCode);
+ if (!result.Success)
+ {
+ var newLines = Environment.NewLine + Environment.NewLine;
+ VsShellUtilities.ShowMessageBox(
+ serviceProvider,
+ $"Selected VB code seems to have errors or to be incomplete:{newLines}{result.GetExceptionsAsString()}",
+ VBToCSConversionTitle,
+ OLEMSGICON.OLEMSGICON_WARNING,
+ OLEMSGBUTTON.OLEMSGBUTTON_OK,
+ OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
+ return;
+ }
- if (result.Success)
+ convertedText = result.ConvertedCode;
+ }
+ catch (Exception ex)
{
- vbCode = result.ConvertedCode;
- return true;
+ VisualStudioInteraction.ShowException(serviceProvider, VBToCSConversionTitle, ex);
+ return;
}
- return false;
+ // Direct output for debugging
+ //string message = convertedText;
+ //VsShellUtilities.ShowMessageBox(
+ // serviceProvider,
+ // message,
+ // VBToCSConversionTitle,
+ // OLEMSGICON.OLEMSGICON_INFO,
+ // OLEMSGBUTTON.OLEMSGBUTTON_OK,
+ // OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST);
+
+ WriteStatusBarText(serviceProvider, "Copied converted C# code to clipboard.");
+
+ Clipboard.SetText(convertedText);
+ }
+
+ static ConversionResult TryConvertingVBToCSCode(string inputCode)
+ {
+ var codeWithOptions = new CodeWithOptions(inputCode)
+ .SetFromLanguage("Visual Basic", 14)
+ .SetToLanguage("C#", 6)
+ .WithDefaultReferences();
+ return CodeConverter.Convert(codeWithOptions);
}
static void WriteStatusBarText(IServiceProvider serviceProvider, string text)
@@ -115,5 +163,32 @@ public static ITextSelection GetCSSelectionInCurrentView(IServiceProvider servic
return viewHost.TextView.Selection;
}
+
+ static IWpfTextViewHost GetCurrentVBViewHost(IServiceProvider serviceProvider)
+ {
+ IWpfTextViewHost viewHost = VisualStudioInteraction.GetCurrentViewHost(serviceProvider);
+ if (viewHost == null)
+ return null;
+
+ ITextDocument textDocument = viewHost.GetTextDocument();
+ if ((textDocument == null) || !IsVBFileName(textDocument.FilePath))
+ return null;
+
+ return viewHost;
+ }
+
+ public static bool IsVBFileName(string fileName)
+ {
+ return fileName.EndsWith(".vb", StringComparison.OrdinalIgnoreCase);
+ }
+
+ public static ITextSelection GetVBSelectionInCurrentView(IServiceProvider serviceProvider)
+ {
+ IWpfTextViewHost viewHost = GetCurrentVBViewHost(serviceProvider);
+ if (viewHost == null)
+ return null;
+
+ return viewHost.TextView.Selection;
+ }
}
}
diff --git a/Vsix/ConvertCSToVBCommand.cs b/Vsix/ConvertCSToVBCommand.cs
index 5646d8d1..06b4474d 100644
--- a/Vsix/ConvertCSToVBCommand.cs
+++ b/Vsix/ConvertCSToVBCommand.cs
@@ -32,7 +32,7 @@ internal sealed class ConvertCSToVBCommand
///
/// VS Package that provides this command, not null.
///
- readonly ConvertCSToVBCommandPackage package;
+ readonly REConverterPackage package;
///
/// Gets the instance of the command.
@@ -58,7 +58,7 @@ IServiceProvider ServiceProvider
/// Initializes the singleton instance of the command.
///
/// Owner package, not null.
- public static void Initialize(ConvertCSToVBCommandPackage package)
+ public static void Initialize(REConverterPackage package)
{
Instance = new ConvertCSToVBCommand(package);
}
@@ -68,7 +68,7 @@ public static void Initialize(ConvertCSToVBCommandPackage package)
/// Adds our command handlers for menu (commands must exist in the command table file)
///
/// Owner package, not null.
- ConvertCSToVBCommand(ConvertCSToVBCommandPackage package)
+ ConvertCSToVBCommand(REConverterPackage package)
{
if (package == null)
{
diff --git a/Vsix/ConvertVBToCSCommand.cs b/Vsix/ConvertVBToCSCommand.cs
new file mode 100644
index 00000000..76f484e8
--- /dev/null
+++ b/Vsix/ConvertVBToCSCommand.cs
@@ -0,0 +1,167 @@
+using System;
+using System.ComponentModel.Design;
+using System.Globalization;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.TextManager.Interop;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Editor;
+using System.Windows;
+using Microsoft.VisualStudio.Text;
+using RefactoringEssentials.Converter;
+using Microsoft.VisualStudio;
+using System.Runtime.InteropServices;
+using System.IO;
+
+namespace RefactoringEssentials.VsExtension
+{
+ ///
+ /// Command handler
+ ///
+ internal sealed class ConvertVBToCSCommand
+ {
+ public const int MainMenuCommandId = 0x0200;
+ public const int CtxMenuCommandId = 0x0201;
+ public const int ProjectItemCtxMenuCommandId = 0x0202;
+
+ ///
+ /// Command menu group (command set GUID).
+ ///
+ public static readonly Guid CommandSet = new Guid("a3378a21-e939-40c9-9e4b-eb0cec7b7854");
+
+ ///
+ /// VS Package that provides this command, not null.
+ ///
+ readonly REConverterPackage package;
+
+ ///
+ /// Gets the instance of the command.
+ ///
+ public static ConvertVBToCSCommand Instance
+ {
+ get;
+ private set;
+ }
+
+ ///
+ /// Gets the service provider from the owner package.
+ ///
+ IServiceProvider ServiceProvider
+ {
+ get
+ {
+ return this.package;
+ }
+ }
+
+ ///
+ /// Initializes the singleton instance of the command.
+ ///
+ /// Owner package, not null.
+ public static void Initialize(REConverterPackage package)
+ {
+ Instance = new ConvertVBToCSCommand(package);
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ /// Adds our command handlers for menu (commands must exist in the command table file)
+ ///
+ /// Owner package, not null.
+ ConvertVBToCSCommand(REConverterPackage package)
+ {
+ if (package == null)
+ {
+ throw new ArgumentNullException(nameof(package));
+ }
+
+ this.package = package;
+
+ OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
+ if (commandService != null)
+ {
+ // Command in main menu
+ var menuCommandID = new CommandID(CommandSet, MainMenuCommandId);
+ var menuItem = new OleMenuCommand(CodeEditorMenuItemCallback, menuCommandID);
+ menuItem.BeforeQueryStatus += CodeEditorMenuItem_BeforeQueryStatus;
+ commandService.AddCommand(menuItem);
+
+ // Command in code editor's context menu
+ var ctxMenuCommandID = new CommandID(CommandSet, CtxMenuCommandId);
+ var ctxMenuItem = new OleMenuCommand(CodeEditorMenuItemCallback, ctxMenuCommandID);
+ ctxMenuItem.BeforeQueryStatus += CodeEditorMenuItem_BeforeQueryStatus;
+ commandService.AddCommand(ctxMenuItem);
+
+ // Command in project item context menu
+ var projectItemCtxMenuCommandID = new CommandID(CommandSet, ProjectItemCtxMenuCommandId);
+ var projectItemCtxMenuItem = new OleMenuCommand(ProjectItemMenuItemCallback, projectItemCtxMenuCommandID);
+ projectItemCtxMenuItem.BeforeQueryStatus += ProjectItemMenuItem_BeforeQueryStatus;
+ commandService.AddCommand(projectItemCtxMenuItem);
+ }
+ }
+
+ void CodeEditorMenuItem_BeforeQueryStatus(object sender, EventArgs e)
+ {
+ var menuItem = sender as OleMenuCommand;
+ if (menuItem != null)
+ {
+ if (!package.DisableConverterInContextMenu)
+ {
+ menuItem.Visible = !CodeConversion.GetVBSelectionInCurrentView(ServiceProvider)?.StreamSelectionSpan.IsEmpty ?? false;
+ }
+ else
+ {
+ menuItem.Visible = false;
+ }
+ }
+ }
+
+ void ProjectItemMenuItem_BeforeQueryStatus(object sender, EventArgs e)
+ {
+ var menuItem = sender as OleMenuCommand;
+ if (menuItem != null)
+ {
+ menuItem.Visible = false;
+ menuItem.Enabled = false;
+
+ if (!package.DisableConverterInContextMenu)
+ {
+ string itemPath = VisualStudioInteraction.GetSingleSelectedItemPath();
+ var fileInfo = new FileInfo(itemPath);
+ if (!CodeConversion.IsVBFileName(fileInfo.Name))
+ return;
+
+ menuItem.Visible = true;
+ menuItem.Enabled = true;
+ }
+ }
+ }
+
+ void CodeEditorMenuItemCallback(object sender, EventArgs e)
+ {
+ string selectedText = CodeConversion.GetVBSelectionInCurrentView(ServiceProvider)?.StreamSelectionSpan.GetText();
+ CodeConversion.PerformVBToCSConversion(ServiceProvider, selectedText);
+ }
+
+ async void ProjectItemMenuItemCallback(object sender, EventArgs e)
+ {
+ string itemPath = VisualStudioInteraction.GetSingleSelectedItemPath();
+ var fileInfo = new FileInfo(itemPath);
+ if (!CodeConversion.IsVBFileName(fileInfo.Name))
+ return;
+
+ try
+ {
+ using (StreamReader reader = new StreamReader(itemPath))
+ {
+ string csCode = await reader.ReadToEndAsync();
+ CodeConversion.PerformVBToCSConversion(ServiceProvider, csCode);
+ }
+ }
+ catch (Exception ex)
+ {
+ VisualStudioInteraction.ShowException(ServiceProvider, CodeConversion.VBToCSConversionTitle, ex);
+ }
+ }
+ }
+}
diff --git a/Vsix/ConvertCSToVBCommandPackage.cs b/Vsix/REConverterPackage.cs
similarity index 93%
rename from Vsix/ConvertCSToVBCommandPackage.cs
rename to Vsix/REConverterPackage.cs
index 29a07cf0..229c839c 100644
--- a/Vsix/ConvertCSToVBCommandPackage.cs
+++ b/Vsix/REConverterPackage.cs
@@ -40,9 +40,9 @@ namespace RefactoringEssentials.VsExtension
[ProvideMenuResource("Menus.ctmenu", 1)]
[ProvideAutoLoad(VSConstants.UICONTEXT.SolutionExistsAndFullyLoaded_string)]
[ProvideOptionPage(typeof(GeneralOptionsDialogPage), "Refactoring Essentials", "General", 0, 0, true)]
- [Guid(ConvertCSToVBCommandPackage.PackageGuidString)]
+ [Guid(REConverterPackage.PackageGuidString)]
[SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1650:ElementDocumentationMustBeSpelledCorrectly", Justification = "pkgdef, VS and vsixmanifest are valid VS terms")]
- public sealed class ConvertCSToVBCommandPackage : Package
+ public sealed class REConverterPackage : Package
{
///
/// ConvertCSToVBCommandPackage GUID string.
@@ -50,9 +50,9 @@ public sealed class ConvertCSToVBCommandPackage : Package
public const string PackageGuidString = "2bc6f609-6f6e-4c54-a908-791dd169911d";
///
- /// Initializes a new instance of the class.
+ /// Initializes a new instance of package class.
///
- public ConvertCSToVBCommandPackage()
+ public REConverterPackage()
{
// Inside this method you can place any initialization code that does not require
// any Visual Studio service because at this point the package object is created but
@@ -69,6 +69,7 @@ public ConvertCSToVBCommandPackage()
protected override void Initialize()
{
ConvertCSToVBCommand.Initialize(this);
+ ConvertVBToCSCommand.Initialize(this);
base.Initialize();
}
diff --git a/Vsix/ConvertCSToVBCommandPackage.vsct b/Vsix/REConverterPackage.vsct
similarity index 62%
rename from Vsix/ConvertCSToVBCommandPackage.vsct
rename to Vsix/REConverterPackage.vsct
index c7c28711..2dd13cbf 100644
--- a/Vsix/ConvertCSToVBCommandPackage.vsct
+++ b/Vsix/REConverterPackage.vsct
@@ -4,7 +4,7 @@
-
+
@@ -18,6 +18,7 @@
+
+
+
+
+
+
-
+
@@ -57,6 +84,9 @@
+
+
+
diff --git a/Vsix/VSPackage.resx b/Vsix/VSPackage.resx
index 5376a5eb..63904226 100644
--- a/Vsix/VSPackage.resx
+++ b/Vsix/VSPackage.resx
@@ -1,27 +1,17 @@
-
-
@@ -127,11 +117,10 @@
System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
-
- ConvertCSToVBCommand Extension
+ Refactoring Essentials
- ConvertCSToVBCommand Visual Studio Extension Detailed Info
+ Refactoring Essentials Extension Details
\ No newline at end of file
diff --git a/Vsix/Vsix.csproj b/Vsix/Vsix.csproj
index 245f8058..937441a1 100644
--- a/Vsix/Vsix.csproj
+++ b/Vsix/Vsix.csproj
@@ -68,7 +68,7 @@
/rootsuffix Roslyn
-
+ Menus.ctmenuDesigner
@@ -110,8 +110,9 @@
+
-
+ Component
From 4c1e442213d742fa8d7db849e07b136def4b4f0f Mon Sep 17 00:00:00 2001
From: Andreas Weizel
Date: Mon, 3 Oct 2016 01:21:58 +0200
Subject: [PATCH 015/236] Excluded VS 15 from VSIX manifest for now, since it's
currently not compatible.
---
Vsix/source.extension.tt | 6 +++---
Vsix/source.extension.vsixmanifest | 6 +++---
2 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/Vsix/source.extension.tt b/Vsix/source.extension.tt
index 68ed7cd9..3acd47df 100644
--- a/Vsix/source.extension.tt
+++ b/Vsix/source.extension.tt
@@ -15,9 +15,9 @@
Images\refactoringessentials-preview.png
-
-
-
+
+
+
diff --git a/Vsix/source.extension.vsixmanifest b/Vsix/source.extension.vsixmanifest
index 8e3be36b..bd454135 100644
--- a/Vsix/source.extension.vsixmanifest
+++ b/Vsix/source.extension.vsixmanifest
@@ -12,9 +12,9 @@
Images\refactoringessentials-preview.png
-
-
-
+
+
+
From 990af96bce2bd494314e4c95ee5b7d98a74fd19f Mon Sep 17 00:00:00 2001
From: Christoph Wille
Date: Mon, 3 Oct 2016 14:09:37 +0200
Subject: [PATCH 016/236] Publish Web site
https://roslyncodeconverter.azurewebsites.net/
---
.../App_Start/SwaggerConfig.cs | 23 ++++++++++++++++---
.../CodeConverterWebApp.csproj | 20 ++++++++--------
CodeConverterWebApp/Web.config | 6 ++---
CodeConverterWebApp/packages.config | 10 ++++----
4 files changed, 38 insertions(+), 21 deletions(-)
diff --git a/CodeConverterWebApp/App_Start/SwaggerConfig.cs b/CodeConverterWebApp/App_Start/SwaggerConfig.cs
index 3d1521d4..64f51558 100644
--- a/CodeConverterWebApp/App_Start/SwaggerConfig.cs
+++ b/CodeConverterWebApp/App_Start/SwaggerConfig.cs
@@ -26,13 +26,13 @@ public static void Register()
// the docs is taken as the default. If your API supports multiple schemes and you want to be explicit
// about them, you can use the "Schemes" option as shown below.
//
- c.Schemes(new[] { "https" });
+ //c.Schemes(new[] { "http", "https" });
// Use "SingleApiVersion" to describe a single version API. Swagger 2.0 includes an "Info" object to
// hold additional metadata for an API. Version and title are required but you can also provide
// additional fields by chaining methods off SingleApiVersion.
//
- c.SingleApiVersion("v1", "RoslynCodeConverter");
+ c.SingleApiVersion("v1", "CodeConverterWebApp");
// If your API has multiple versions, use "MultipleApiVersions" instead of "SingleApiVersion".
// In this case, you must provide a lambda that tells Swashbuckle which actions should be
@@ -57,6 +57,7 @@ public static void Register()
//c.BasicAuth("basic")
// .Description("Basic HTTP Authentication");
//
+ // NOTE: You must also configure 'EnableApiKeySupport' below in the SwaggerUI section
//c.ApiKey("apiKey")
// .Description("API Key Authentication")
// .Name("apiKey")
@@ -204,6 +205,11 @@ public static void Register()
//
//c.DocExpansion(DocExpansion.List);
+ // Specify which HTTP operations will have the 'Try it out!' option. An empty paramter list disables
+ // it for all operations.
+ //
+ //c.SupportedSubmitMethods("GET", "HEAD");
+
// Use the CustomAsset option to provide your own version of assets used in the swagger-ui.
// It's typically used to instruct Swashbuckle to return your version instead of the default
// when a request is made for "index.html". As with all custom content, the file must be included
@@ -222,7 +228,18 @@ public static void Register()
// If your API supports the OAuth2 Implicit flow, and you've described it correctly, according to
// the Swagger 2.0 specification, you can enable UI support as shown below.
//
- //c.EnableOAuth2Support("test-client-id", "test-realm", "Swagger UI");
+ //c.EnableOAuth2Support(
+ // clientId: "test-client-id",
+ // clientSecret: null,
+ // realm: "test-realm",
+ // appName: "Swagger UI"
+ // //additionalQueryStringParams: new Dictionary() { { "foo", "bar" } }
+ //);
+
+ // If your API supports ApiKey, you can override the default values.
+ // "apiKeyIn" can either be "query" or "header"
+ //
+ //c.EnableApiKeySupport("apiKey", "header");
});
}
}
diff --git a/CodeConverterWebApp/CodeConverterWebApp.csproj b/CodeConverterWebApp/CodeConverterWebApp.csproj
index 05d4db93..3f57a776 100644
--- a/CodeConverterWebApp/CodeConverterWebApp.csproj
+++ b/CodeConverterWebApp/CodeConverterWebApp.csproj
@@ -1,7 +1,7 @@
-
-
+
+ Debug
@@ -43,17 +43,17 @@
4
-
- ..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.1\lib\net45\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.dll
+
+ ..\packages\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.1.0.2\lib\net45\Microsoft.CodeDom.Providers.DotNetCompilerPlatform.dllTrue
-
- ..\packages\Newtonsoft.Json.8.0.3\lib\net45\Newtonsoft.Json.dll
+
+ ..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dllTrue
- ..\packages\Swashbuckle.Core.5.3.2\lib\net40\Swashbuckle.Core.dll
+ ..\packages\Swashbuckle.Core.5.4.0\lib\net40\Swashbuckle.Core.dllTrue
@@ -134,7 +134,7 @@
-
+
@@ -207,8 +207,8 @@
This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.
-
-
+
+
+
\ No newline at end of file
diff --git a/DocGenerator.2017/Properties/AssemblyInfo.cs b/DocGenerator.2017/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..c8bd4539
--- /dev/null
+++ b/DocGenerator.2017/Properties/AssemblyInfo.cs
@@ -0,0 +1,5 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("Refactoring Essentials Documentation Generator")]
\ No newline at end of file
diff --git a/DocGenerator.2017/packages.config b/DocGenerator.2017/packages.config
new file mode 100644
index 00000000..af56ed4c
--- /dev/null
+++ b/DocGenerator.2017/packages.config
@@ -0,0 +1,25 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/RefactoringEssentials.2017.sln b/RefactoringEssentials.2017.sln
new file mode 100644
index 00000000..9786f9a4
--- /dev/null
+++ b/RefactoringEssentials.2017.sln
@@ -0,0 +1,211 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.25920.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".nuget", ".nuget", "{CF2B2ADB-325E-49D2-8718-2FBEFE973476}"
+ ProjectSection(SolutionItems) = preProject
+ .nuget\packages.config = .nuget\packages.config
+ EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{E7481F91-77A4-49F6-ACC7-B8145827C384}"
+ ProjectSection(SolutionItems) = preProject
+ README.md = README.md
+ EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Vsix", "Vsix.2017\Vsix.csproj", "{99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}"
+ ProjectSection(ProjectDependencies) = postProject
+ {7FB64621-DF93-48DE-995D-8CB0804F6003} = {7FB64621-DF93-48DE-995D-8CB0804F6003}
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D} = {31E950AF-20E9-43AB-8CB7-134598FB8A6D}
+ EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RefactoringEssentials", "RefactoringEssentials.2017\RefactoringEssentials.csproj", "{C465A5DC-AD28-49A2-89C0-F81838814A7E}"
+ ProjectSection(ProjectDependencies) = postProject
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D} = {31E950AF-20E9-43AB-8CB7-134598FB8A6D}
+ EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Demonstration", "Demonstration\Demonstration.csproj", "{203FF5F7-8F0A-43C5-8BB5-723C492A42DA}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BuildTools", "BuildTools\BuildTools.csproj", "{31E950AF-20E9-43AB-8CB7-134598FB8A6D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests", "Tests.2017\Tests.csproj", "{21DBA1CE-AF55-4159-B04B-B8C621BE8921}"
+EndProject
+Project("{F184B08F-C81C-45F6-A57F-5ABD9991F28F}") = "Demonstration.VB", "Demonstration.VB\Demonstration.VB.vbproj", "{9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DocGenerator", "DocGenerator.2017\DocGenerator.csproj", "{7FB64621-DF93-48DE-995D-8CB0804F6003}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Debug|x86 = Debug|x86
+ Mono_Debug|Any CPU = Mono_Debug|Any CPU
+ Mono_Debug|x86 = Mono_Debug|x86
+ Mono_Release|Any CPU = Mono_Release|Any CPU
+ Mono_Release|x86 = Mono_Release|x86
+ net_4_5_Debug|Any CPU = net_4_5_Debug|Any CPU
+ net_4_5_Debug|x86 = net_4_5_Debug|x86
+ net_4_5_Release|Any CPU = net_4_5_Release|Any CPU
+ net_4_5_Release|x86 = net_4_5_Release|x86
+ Release|Any CPU = Release|Any CPU
+ Release|x86 = Release|x86
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Debug|x86.Build.0 = Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Mono_Debug|Any CPU.ActiveCfg = Mono_Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Mono_Debug|Any CPU.Build.0 = Mono_Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Mono_Debug|x86.ActiveCfg = Mono_Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Mono_Release|Any CPU.ActiveCfg = Mono_Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Mono_Release|Any CPU.Build.0 = Mono_Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Mono_Release|x86.ActiveCfg = Mono_Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.net_4_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.net_4_5_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.net_4_5_Debug|x86.ActiveCfg = Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.net_4_5_Debug|x86.Build.0 = Debug|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.net_4_5_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.net_4_5_Release|Any CPU.Build.0 = Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.net_4_5_Release|x86.ActiveCfg = Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.net_4_5_Release|x86.Build.0 = Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Release|Any CPU.Build.0 = Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Release|x86.ActiveCfg = Release|Any CPU
+ {99498EF8-C9E0-433B-8D7B-EA8E9E66F0C7}.Release|x86.Build.0 = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Debug|x86.Build.0 = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Mono_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Mono_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Mono_Debug|x86.ActiveCfg = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Mono_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Mono_Release|Any CPU.Build.0 = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Mono_Release|x86.ActiveCfg = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.net_4_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.net_4_5_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.net_4_5_Debug|x86.ActiveCfg = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.net_4_5_Debug|x86.Build.0 = Debug|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.net_4_5_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.net_4_5_Release|Any CPU.Build.0 = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.net_4_5_Release|x86.ActiveCfg = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.net_4_5_Release|x86.Build.0 = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Release|Any CPU.Build.0 = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Release|x86.ActiveCfg = Release|Any CPU
+ {C465A5DC-AD28-49A2-89C0-F81838814A7E}.Release|x86.Build.0 = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Debug|x86.Build.0 = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Mono_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Mono_Debug|x86.ActiveCfg = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Mono_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Mono_Release|x86.ActiveCfg = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.net_4_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.net_4_5_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.net_4_5_Debug|x86.ActiveCfg = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.net_4_5_Debug|x86.Build.0 = Debug|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.net_4_5_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.net_4_5_Release|Any CPU.Build.0 = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.net_4_5_Release|x86.ActiveCfg = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.net_4_5_Release|x86.Build.0 = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Release|Any CPU.Build.0 = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Release|x86.ActiveCfg = Release|Any CPU
+ {203FF5F7-8F0A-43C5-8BB5-723C492A42DA}.Release|x86.Build.0 = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Debug|x86.Build.0 = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Mono_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Mono_Debug|x86.ActiveCfg = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Mono_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Mono_Release|x86.ActiveCfg = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.net_4_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.net_4_5_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.net_4_5_Debug|x86.ActiveCfg = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.net_4_5_Debug|x86.Build.0 = Debug|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.net_4_5_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.net_4_5_Release|Any CPU.Build.0 = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.net_4_5_Release|x86.ActiveCfg = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.net_4_5_Release|x86.Build.0 = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Release|Any CPU.Build.0 = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Release|x86.ActiveCfg = Release|Any CPU
+ {31E950AF-20E9-43AB-8CB7-134598FB8A6D}.Release|x86.Build.0 = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Debug|x86.Build.0 = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Mono_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Mono_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Mono_Debug|x86.ActiveCfg = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Mono_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Mono_Release|Any CPU.Build.0 = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Mono_Release|x86.ActiveCfg = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.net_4_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.net_4_5_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.net_4_5_Debug|x86.ActiveCfg = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.net_4_5_Debug|x86.Build.0 = Debug|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.net_4_5_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.net_4_5_Release|Any CPU.Build.0 = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.net_4_5_Release|x86.ActiveCfg = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.net_4_5_Release|x86.Build.0 = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Release|Any CPU.Build.0 = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Release|x86.ActiveCfg = Release|Any CPU
+ {21DBA1CE-AF55-4159-B04B-B8C621BE8921}.Release|x86.Build.0 = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Debug|x86.Build.0 = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Mono_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Mono_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Mono_Debug|x86.ActiveCfg = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Mono_Debug|x86.Build.0 = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Mono_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Mono_Release|Any CPU.Build.0 = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Mono_Release|x86.ActiveCfg = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Mono_Release|x86.Build.0 = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.net_4_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.net_4_5_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.net_4_5_Debug|x86.ActiveCfg = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.net_4_5_Debug|x86.Build.0 = Debug|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.net_4_5_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.net_4_5_Release|Any CPU.Build.0 = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.net_4_5_Release|x86.ActiveCfg = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.net_4_5_Release|x86.Build.0 = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Release|Any CPU.Build.0 = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Release|x86.ActiveCfg = Release|Any CPU
+ {9FD0CFFC-CEDF-42DC-A344-B3E8F4EDF7C7}.Release|x86.Build.0 = Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Debug|x86.ActiveCfg = Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Debug|x86.Build.0 = Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Mono_Debug|Any CPU.ActiveCfg = Mono_Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Mono_Debug|Any CPU.Build.0 = Mono_Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Mono_Debug|x86.ActiveCfg = Mono_Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Mono_Debug|x86.Build.0 = Mono_Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Mono_Release|Any CPU.ActiveCfg = Mono_Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Mono_Release|Any CPU.Build.0 = Mono_Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Mono_Release|x86.ActiveCfg = Mono_Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Mono_Release|x86.Build.0 = Mono_Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.net_4_5_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.net_4_5_Debug|Any CPU.Build.0 = Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.net_4_5_Debug|x86.ActiveCfg = Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.net_4_5_Debug|x86.Build.0 = Debug|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.net_4_5_Release|Any CPU.ActiveCfg = Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.net_4_5_Release|Any CPU.Build.0 = Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.net_4_5_Release|x86.ActiveCfg = Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.net_4_5_Release|x86.Build.0 = Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Release|Any CPU.Build.0 = Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Release|x86.ActiveCfg = Release|Any CPU
+ {7FB64621-DF93-48DE-995D-8CB0804F6003}.Release|x86.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/RefactoringEssentials.2017/CodeAnalyzers.CSharp.html b/RefactoringEssentials.2017/CodeAnalyzers.CSharp.html
new file mode 100644
index 00000000..c18e745c
--- /dev/null
+++ b/RefactoringEssentials.2017/CodeAnalyzers.CSharp.html
@@ -0,0 +1,142 @@
+
+
+
+
+
+
+
+
+
+
Supported Code Analyzers
+
120 code analyzers for C#
+
+
Suggests using the class declaring a static function when calling it (AccessToStaticMemberViaDerivedTypeAnalyzer)
+
When initializing explicitly typed local variable or array type, array creation expression can be replaced with array initializer. (ArrayCreationCanBeReplacedWithArrayInitializerAnalyzer)
+
Asynchronous methods should return a Task instead of void (AvoidAsyncVoidAnalyzer)
+
Base parameter has 'params' modifier, but missing in overrider (BaseMemberHasParamsAnalyzer)
+
Call to base member with implicit default parameters (BaseMethodCallWithDefaultParameterAnalyzer)
+
Parameter name differs in base declaration (BaseMethodParameterNameMismatchAnalyzer)
+
Bitwise operation on enum which has no [Flags] attribute (BitwiseOperatorOnEnumWithoutFlagsAnalyzer)
+
Finds potentially erroneous calls to Object.Equals (CallToObjectEqualsViaBaseAnalyzer)
+
Possible compare of value type with 'null' (CompareNonConstrainedGenericWithNullAnalyzer)
+
Comparison of floating point numbers with equality operator (CompareOfFloatsByEqualityOperatorAnalyzer)
+
'?:' expression has identical true and false branches (ConditionalTernaryEqualBranchAnalyzer)
+
Expression is always 'true' or always 'false' (ConditionIsAlwaysTrueOrFalseAnalyzer)
+
Condition is always 'true' or always 'false' (ConstantConditionAnalyzer)
+
Finds redundant null coalescing expressions such as expr ?? expr (ConstantNullCoalescingConditionAnalyzer)
+
Convert anonymous method to method group (ConvertClosureToMethodGroupAnalyzer)
+
'?:' expression can be converted to '??' expression (ConvertConditionalTernaryToNullCoalescingAnalyzer)
+
Convert 'if-do-while' to 'while' statement (ConvertIfDoToWhileAnalyzer)
+
'if' statement can be re-written as 'switch' statement (ConvertIfStatementToSwitchStatementAnalyzer)
+
Convert 'if' to '&&' expression (ConvertIfToAndExpressionAnalyzer)
+
Convert 'if' to '||' expression (ConvertIfToOrExpressionAnalyzer)
+
Convert 'Nullable<T>' to the short form 'T?' (ConvertNullableToShortFormAnalyzer)
+
If all fields, properties and methods members are static, the class can be made static. (ConvertToStaticTypeAnalyzer)
+
Delegate subtraction has unpredictable result (DelegateSubtractionAnalyzer)
+
Warns about calls to virtual member functions occuring in the constructor (DoNotCallOverridableMethodsInConstructorAnalyzer)
+
Double negation is redundant (DoubleNegationOperatorAnalyzer)
+
An empty public constructor without parameters is redundant. (EmptyConstructorAnalyzer)
+
Empty destructor is redundant (EmptyDestructorAnalyzer)
+
Empty control statement body (EmptyEmbeddedStatementAnalyzer)
+
A catch clause that catches System.Exception and has an empty body (EmptyGeneralCatchClauseAnalyzer)
+
Empty namespace declaration is redundant (EmptyNamespaceAnalyzer)
+
Empty statement is redundant (EmptyStatementAnalyzer)
+
The default underlying type of enums is int, so defining it explicitly is redundant. (EnumUnderlyingTypeIsIntAnalyzer)
+
Comparing equal expression for equality is usually useless (EqualExpressionComparisonAnalyzer)
+
Event unsubscription via anonymous delegate is useless (EventUnsubscriptionViaAnonymousDelegateAnalyzer)
+
Convert field to readonly (FieldCanBeMadeReadOnlyAnalyzer)
+
'for' loop control variable is never modified (ForControlVariableIsNeverModifiedAnalyzer)
+
Finds issues with format strings (FormatStringProblemAnalyzer)
+
'true' is redundant as for statement condition (ForStatementConditionIsTrueAnalyzer)
+
Function does not reach its end or a 'return' statement by any of possible execution paths (FunctionNeverReturnsAnalyzer)
+
If an extension method is called as static method convert it to method syntax (InvokeAsExtensionMethodAnalyzer)
+
Local variable has the same name as a member and hides it (LocalVariableHidesMemberAnalyzer)
+
Local variable is never used (LocalVariableNotUsedAnalyzer)
+
Lowercase 'l' is often confused with '1' (LongLiteralEndingLowerLAnalyzer)
+
Member hides static member from outer class (MemberHidesStaticFromOuterClassAnalyzer)
+
Method with optional parameter is hidden by overload (MethodOverloadWithOptionalParameterAnalyzer)
+
Suggest the usage of the nameof operator (NameOfSuggestionAnalyzer)
+
Non public methods are not found by NUnit (NonPublicMethodWithTestAttributeAnalyzer)
+
Non-readonly field referenced in 'GetHashCode()' (NonReadonlyReferencedInGetHashCodeAnalyzer)
+
Shows NotImplementedException throws in the quick task bar (NotImplementedExceptionAnalyzer)
+
Cannot resolve symbol in text argument (NotResolvedInTextAnalyzer)
+
Possible unassigned object created by 'new' (ObjectCreationAsStatementAnalyzer)
+
Operator Is can be used instead of comparing object GetType() and instances of System.Type object (OperatorIsCanBeUsedAnalyzer)
+
C# doesn't support optional 'ref' or 'out' parameters (OptionalParameterRefOutAnalyzer)
+
Parameter has the same name as a member and hides it (ParameterHidesMemberAnalyzer)
+
Parameter is assigned but its value is never used (ParameterOnlyAssignedAnalyzer)
+
Parameter name differs in partial method definition (PartialMethodParameterNameMismatchAnalyzer)
+
Class is declared partial but has only one part (PartialTypeWithSinglePartAnalyzer)
+
Possible mistaken call to 'object.GetType()' (PossibleMistakenCallToGetTypeAnalyzer)
+
Constructor in abstract class should not be public (PublicConstructorInAbstractClassAnalyzer)
+
Redundant explicit property name (RedundantAnonymousTypePropertyNameAnalyzer)
+
Redundant explicit argument name specification (RedundantArgumentNameAnalyzer)
+
Parentheses are redundant if attribute has no arguments (RedundantAttributeParenthesesAnalyzer)
+
This is generated by the compiler and can be safely removed (RedundantBaseConstructorCallAnalyzer)
+
'base.' is redundant and can safely be removed (RedundantBaseQualifierAnalyzer)
+
Redundant case label (RedundantCaseLabelAnalyzer)
+
Check for inequality before assignment is redundant if (x != value) x = value; (RedundantCheckBeforeAssignmentAnalyzer)
+
Redundant comma in array initializer (RedundantCommaInArrayInitializerAnalyzer)
+
Initializing field with default value is redundant (RedundantDefaultFieldInitializerAnalyzer)
+
Explicit delegate creation expression is redundant (RedundantDelegateCreationAnalyzer)
This service is brought to you by the same people that created http://codeconverter.sharpdevelop.net/.
- In comparison, this service today supports only C# to VB.NET, however in their respective latest versions - whereas the NRefactory-based
+ In comparison, this service today supports only C# to VB.NET (and vice versa), however in their respective latest versions - whereas the NRefactory-based
older service is C# 5.0 only (and won't be updated any more).