public static bool CompileVisualBasic(
IEnumerable <string> sourceFiles,
string outputPath,
IEnumerable <string> references,
IEnumerable <KeyValuePair <string, object> > defines,
out List <string> messages
)
{
VB.VisualBasicCompilation compilation =
CreateVisualBasicCompilation(
sourceFiles,
Path.GetFileName(outputPath),
references,
defines,
out messages
);
// compile and write results
var result = compilation.Emit(outputPath);
foreach (var diag in result.Diagnostics)
{
messages.Add(diag.ToString());
}
return(result.Success);
}
public static Dictionary <string, CSharpSyntaxNode> ConvertMultiple(VBasic.VisualBasicCompilation compilation, IEnumerable <VBasic.VisualBasicSyntaxTree> syntaxTrees)
{
var cSharpFirstPass = syntaxTrees.ToDictionary(tree => tree.FilePath ?? "unknown",
tree => (CSharpSyntaxTree)SyntaxFactory.SyntaxTree(tree.GetRoot().Accept(new NodesVisitor(compilation.GetSemanticModel(tree, true)))));
var cSharpCompilation = CSharpCompilation.Create("Conversion", cSharpFirstPass.Values, compilation.References);
return(cSharpFirstPass.ToDictionary(cs => cs.Key, cs => new CompilationErrorFixer(cSharpCompilation, cs.Value).Fix()));
}
public static bool CompileVisualBasic(
IEnumerable <string> sourceFiles,
string outputPath,
IEnumerable <string> references,
IEnumerable <KeyValuePair <string, object> > defines,
bool debug,
out List <string> messages
)
{
VB.VisualBasicCompilation compilation =
CreateVisualBasicCompilation(
sourceFiles,
Path.GetFileName(outputPath),
references,
defines,
debug,
out messages
);
// compile and write results
EmitResult result;
if (debug)
{
string pdbName = Path.Combine(
Path.GetDirectoryName(outputPath),
Path.GetFileNameWithoutExtension(outputPath) + ".pdb"
);
result = compilation.Emit(outputPath, pdbName);
}
else
{
result = compilation.Emit(outputPath);
}
foreach (var diag in result.Diagnostics)
{
messages.Add(diag.ToString());
}
return(result.Success);
}
public static CSharpSyntaxNode ConvertCompilationTree(VBasic.VisualBasicCompilation compilation, VBasic.VisualBasicSyntaxTree tree)
{
var visualBasicSyntaxVisitor = new VisualBasicConverter.NodesVisitor(compilation.GetSemanticModel(tree, true));
return(tree.GetRoot().Accept(visualBasicSyntaxVisitor.TriviaConvertingVisitor));
}
private bool TryAnalyzeCsConversion(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax vbNode, ITypeSymbol csType,
ITypeSymbol csConvertedType, Conversion vbConversion, ITypeSymbol vbConvertedType, ITypeSymbol vbType,
VBasic.VisualBasicCompilation vbCompilation, bool isConst, out TypeConversionKind typeConversionKind)
{
var csConversion = _csCompilation.ClassifyConversion(csType, csConvertedType);
bool isConvertToString =
(vbConversion.IsString || vbConversion.IsReference && vbConversion.IsNarrowing) && vbConvertedType.SpecialType == SpecialType.System_String;
bool isArithmetic = vbNode.IsKind(Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.AddExpression,
Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.SubtractExpression,
Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.MultiplyExpression,
Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.DivideExpression,
Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.IntegerDivideExpression);
if (!csConversion.Exists || csConversion.IsUnboxing)
{
if (ConvertStringToCharLiteral(vbNode, vbType, vbConvertedType, out _))
{
typeConversionKind =
TypeConversionKind.Identity; // Already handled elsewhere by other usage of method
return(true);
}
if (vbType.SpecialType == SpecialType.System_String && vbConvertedType.IsArrayOf(SpecialType.System_Char))
{
typeConversionKind = TypeConversionKind.StringToCharArray;
return(true);
}
if (isConvertToString || vbConversion.IsNarrowing)
{
typeConversionKind = TypeConversionKind.Conversion;
return(true);
}
}
else if (vbConversion.IsWidening && vbConversion.IsNumeric && csConversion.IsImplicit &&
csConversion.IsNumeric)
{
// Safe overapproximation: A cast is really only needed to help resolve the overload for the operator/method used.
// e.g. When VB "&" changes to C# "+", there are lots more overloads available that implicit casts could match.
// e.g. sbyte * ulong uses the decimal * operator in VB. In C# it's ambiguous - see ExpressionTests.vb "TestMul".
typeConversionKind = TypeConversionKind.NonDestructiveCast;
return(true);
}
else if (csConversion.IsExplicit && csConversion.IsEnumeration || csConversion.IsBoxing)
{
typeConversionKind = TypeConversionKind.NonDestructiveCast;
return(true);
}
else if (isArithmetic)
{
var arithmeticConversion =
vbCompilation.ClassifyConversion(vbConvertedType,
vbCompilation.GetTypeByMetadataName("System.Int32"));
if (arithmeticConversion.IsWidening && !arithmeticConversion.IsIdentity)
{
typeConversionKind = TypeConversionKind.Conversion;
return(true);
}
}
else if (csConversion.IsExplicit && csConversion.IsNumeric && vbConversion.IsNarrowing && isConst)
{
typeConversionKind = IsImplicitConstantConversion(vbNode) ? TypeConversionKind.Identity : TypeConversionKind.NonDestructiveCast;
return(true);
}
else if (csConversion.IsExplicit && vbConversion.IsNumeric && vbType.TypeKind != TypeKind.Enum)
{
typeConversionKind = IsImplicitConstantConversion(vbNode) ? TypeConversionKind.Identity :
TypeConversionKind.Conversion;
return(true);
}
else if (csConversion.IsExplicit && vbConversion.IsIdentity && csConversion.IsNumeric && vbType.TypeKind != TypeKind.Enum)
{
typeConversionKind = TypeConversionKind.Conversion;
return(true);
}
else if (isConvertToString && vbType.SpecialType == SpecialType.System_Object)
{
typeConversionKind = TypeConversionKind.Conversion;
return(true);
}
else if (csConversion.IsNullable && csConvertedType.SpecialType == SpecialType.System_Boolean)
{
typeConversionKind = TypeConversionKind.NullableBool;
return(true);
}
else if (csConversion.IsExplicit)
{
typeConversionKind = TypeConversionKind.DestructiveCast;
return(true);
}
typeConversionKind = csConversion.IsIdentity ? TypeConversionKind.Identity : TypeConversionKind.Unknown;
return(false);
}
public static CSharpSyntaxNode ConvertSingle(VBasic.VisualBasicCompilation compilation, VBasic.VisualBasicSyntaxTree syntaxTree)
{
return(ConvertMultiple(compilation, new[] { syntaxTree }).Values.Single());
}