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