private bool CanBeNull(VBSyntax.ExpressionSyntax vbNode)
{
if (vbNode.IsKind(VBSyntaxKind.StringLiteralExpression))
{
return(false);
}
var constantAnalysis = _semanticModel.GetConstantValue(vbNode);
if (constantAnalysis.HasValue && constantAnalysis.Value != null)
{
return(false);
}
return(true);
}
private ExpressionStatementSyntax CreateNewArrayAssignment(VBSyntax.ExpressionSyntax vbArrayExpression,
ExpressionSyntax csArrayExpression, List <ExpressionSyntax> convertedBounds,
int nodeSpanStart)
{
var arrayRankSpecifierSyntax = SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SeparatedList(convertedBounds));
var convertedType = (IArrayTypeSymbol)_semanticModel.GetTypeInfo(vbArrayExpression).ConvertedType;
var typeSyntax = GetTypeSyntaxFromTypeSymbol(convertedType.ElementType, nodeSpanStart);
var arrayCreation =
SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(typeSyntax,
SyntaxFactory.SingletonList(arrayRankSpecifierSyntax)));
var assignmentExpressionSyntax =
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, csArrayExpression, arrayCreation);
var newArrayAssignment = SyntaxFactory.ExpressionStatement(assignmentExpressionSyntax);
return(newArrayAssignment);
}
private bool UnpackExpressionFromStatement(StatementSyntax statementSyntax, out ExpressionSyntax expression)
{
if (statementSyntax is ReturnStatementSyntax)
{
expression = ((ReturnStatementSyntax)statementSyntax).Expression;
}
else if (statementSyntax is YieldStatementSyntax)
{
expression = ((YieldStatementSyntax)statementSyntax).Expression;
}
else
{
expression = null;
}
return(expression != null);
}
private void VisitMethodsVisualBasic(SyntaxNodeAnalysisContext ctx)
{
if (!(ctx.Node is VBSyntax.MethodBlockSyntax node))
{
return;
}
//Iterating over the list of annotation for a given method
foreach (var attribute in node.BlockStatement.AttributeLists)
{
if (attribute.Attributes.Count == 0)
{
continue; //Bound check .. Unlikely to happens
}
var att = attribute.Attributes[0];
//Extract the annotation identifier
if (!(att.Name is VBSyntax.IdentifierNameSyntax identifier))
{
continue;
}
if (identifier.Identifier.Text != "ValidateInput")
{
continue;
}
var hasArgumentFalse = false;
VBSyntax.ExpressionSyntax expression = null;
foreach (var arg in att.ArgumentList.Arguments)
{
var literal = (VBSyntax.LiteralExpressionSyntax)arg.GetExpression();
if (literal.Token.ValueText != "False")
{
continue;
}
hasArgumentFalse = true;
expression = arg.GetExpression();
}
if (hasArgumentFalse && expression != null)
{
ctx.ReportDiagnostic(Diagnostic.Create(Rule, expression.GetLocation()));
}
}
}
public ExpressionSyntax VbCoerceToNonNullString(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, TypeInfo typeInfo, bool knownNotNull = false)
{
if (IsNothingOrEmpty(vbNode))
{
return(EmptyStringExpression());
}
if (knownNotNull || !CanBeNull(vbNode))
{
return(csNode);
}
csNode = typeInfo.Type.SpecialType == SpecialType.System_String
? SyntaxFactory.ParenthesizedExpression(Coalesce(csNode, EmptyStringExpression()))
: Coalesce(csNode, EmptyCharArrayExpression());
return(VbCoerceToString(csNode, typeInfo));
}
private StatementSyntax WrapRootExpression(ExpressionSyntax expressionSyntax)
{
InvocationExpressionSyntax invocationExpression = expressionSyntax as InvocationExpressionSyntax;
if (invocationExpression != null)
{
var lastExpression = expressionSyntax.FollowProperty(exp => exp.TypeSwitch(
(InvocationExpressionSyntax e) => e.Expression,
(ParenthesizedExpressionSyntax e) => e.Expression,
(CastExpressionSyntax e) => e.Expression,
(MemberAccessExpressionSyntax e) => e.Expression
)).LastOrDefault();
if (lastExpression != null && !(lastExpression is IdentifierNameSyntax || lastExpression is InstanceExpressionSyntax))
{
return(SyntaxFactory.CallStatement(expressionSyntax));
}
}
return(SyntaxFactory.ExpressionStatement(expressionSyntax));
}
public ExpressionSyntax GetConstantOrNull(VBSyntax.ExpressionSyntax vbNode, ITypeSymbol type, ExpressionSyntax csNode)
{
var vbOperation = _semanticModel.GetOperation(vbNode).SkipParens(true);
// Guideline tradeoff: Usually would aim for erring on the side of correct runtime behaviour. But making lots of simple constants unreadable for the sake of an edge case that will turn into an easily fixed compile error seems overkill.
// See https://github.com/icsharpcode/CodeConverter/blob/master/.github/CONTRIBUTING.md#deciding-what-the-output-should-be
if (Equals(vbOperation.Type, type) && IsProbablyConstExpression(vbOperation))
{
return(csNode);
}
if (TryCompileTimeEvaluate(vbOperation, out var result) && ConversionsTypeFullNames.TryGetValue(type.GetFullMetadataName(), out var method))
{
result = method.Invoke(null, new[] { result });
return(LiteralConversions.GetLiteralExpression(result, convertedType: type));
}
return(null);
}
private ExpressionSyntax VbCoerceToString(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, TypeInfo typeInfo)
{
bool isStringType = typeInfo.Type.SpecialType == SpecialType.System_String;
if (IsNothingOrEmpty(vbNode))
{
return(EmptyStringExpression());
}
if (!CanBeNull(vbNode))
{
return(csNode);
}
csNode = isStringType
? SyntaxFactory.ParenthesizedExpression(Coalesce(csNode, EmptyStringExpression()))
: Coalesce(csNode, EmptyCharArrayExpression());
return(!isStringType?NewStringFromArg(csNode) : csNode);
}
public (ExpressionSyntax csLeft, ExpressionSyntax csRight) AdjustForVbStringComparison(VBSyntax.ExpressionSyntax vbLeft, ExpressionSyntax csLeft, TypeInfo lhsTypeInfo, VBSyntax.ExpressionSyntax vbRight, ExpressionSyntax csRight, TypeInfo rhsTypeInfo)
{
if (OptionCompareTextCaseInsensitive)
{
_extraUsingDirectives.Add("System.Globalization");
var compareOptions = SyntaxFactory.Argument(GetCompareTextCaseInsensitiveCompareOptions());
var compareString = SyntaxFactory.InvocationExpression(ValidSyntaxFactory.MemberAccess(nameof(CultureInfo), nameof(CultureInfo.CurrentCulture),
nameof(CultureInfo.CompareInfo), nameof(CompareInfo.Compare)),
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[]
{ SyntaxFactory.Argument(csLeft), SyntaxFactory.Argument(csRight), compareOptions })));
csLeft = compareString;
csRight = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression,
SyntaxFactory.Literal(0));
}
else
{
(csLeft, csRight) = VbCoerceToString(vbLeft, csLeft, lhsTypeInfo, vbRight, csRight, rhsTypeInfo);
}
return(csLeft, csRight);
}
public (ExpressionSyntax lhs, ExpressionSyntax rhs) VbCoerceToString(VBSyntax.ExpressionSyntax vbLeft, ExpressionSyntax csLeft, TypeInfo lhsTypeInfo, VBSyntax.ExpressionSyntax vbRight, ExpressionSyntax csRight, TypeInfo rhsTypeInfo)
{
return(VbCoerceToString(vbLeft, csLeft, lhsTypeInfo), VbCoerceToString(vbRight, csRight, rhsTypeInfo));
}
public static Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax SkipParens(this Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax expression)
{
if (expression == null)
{
return(null);
}
while (expression is Microsoft.CodeAnalysis.VisualBasic.Syntax.ParenthesizedExpressionSyntax pes)
{
expression = pes.Expression;
}
return(expression);
}
public static IOperation GetExpressionOperation(this SemanticModel semanticModel, Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax expressionSyntax)
{
var op = semanticModel.GetOperation(expressionSyntax);
while (true)
{
switch (op)
{
case IArgumentOperation argumentOperation:
op = argumentOperation.Value;
continue;
case IConversionOperation conversionOperation:
op = conversionOperation.Operand;
continue;
case IParenthesizedOperation parenthesizedOperation:
op = parenthesizedOperation.Operand;
continue;
default:
return(op);
}
}
}
private static bool IsNonEmptyStringLiteral(VBSyntax.ExpressionSyntax vbExpr)
{
return(vbExpr.SkipIntoParens().IsKind(VBSyntaxKind.StringLiteralExpression) && vbExpr is VBSyntax.LiteralExpressionSyntax literal && !IsEmptyString(literal));
}
public virtual void VisitInvocationAndCreation(VBSyntax.ExpressionSyntax node,
VBSyntax.ArgumentListSyntax argList,
ExecutionState state,
Configuration projectConfiguration)
{
}
public static bool IsIntegralType(this Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax e, SemanticModel semanticModel)
{
return(IsIntegralType(semanticModel.GetTypeInfo(e).Type?.SpecialType));
}
public (ExpressionSyntax lhs, ExpressionSyntax rhs) VbCoerceToNonNullString(VBSyntax.ExpressionSyntax vbLeft, ExpressionSyntax csLeft, TypeInfo lhsTypeInfo, bool leftKnownNotNull, VBSyntax.ExpressionSyntax vbRight, ExpressionSyntax csRight, TypeInfo rhsTypeInfo, bool rightKnownNotNull)
{
if (IsNonEmptyStringLiteral(vbLeft) || IsNonEmptyStringLiteral(vbRight))
{
// If one of the strings is "foo", the other string won't equal it if it's null or empty, so it doesn't matter which one we use in comparison
return(csLeft, csRight);
}
return(VbCoerceToNonNullString(vbLeft, csLeft, lhsTypeInfo, leftKnownNotNull), VbCoerceToNonNullString(vbRight, csRight, rhsTypeInfo, rightKnownNotNull));
}
/// <summary>
/// This is a conversion heavily based on Microsoft.CodeAnalysis.VisualBasic.Syntax.InternalSyntax.SyntaxExtensions.ExtractAnonymousTypeMemberName from 1bbbfc28a8e4493b4057e171310343a4c7ba826c
/// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0
/// </summary>
public static SyntaxToken?ExtractAnonymousTypeMemberName(this VBSyntax.ExpressionSyntax input)
{
bool isNameDictionaryAccess;
Stack <VBSyntax.ConditionalAccessExpressionSyntax> conditionalAccessStack = null;
while (true)
{
switch (input.Kind())
{
case VBasic.SyntaxKind.IdentifierName: {
return(((VBSyntax.IdentifierNameSyntax)input).Identifier);
}
case VBasic.SyntaxKind.XmlName: {
var xmlNameInferredFrom = (VBSyntax.XmlNameSyntax)input;
var name = xmlNameInferredFrom.LocalName;
// CONVERSION NOTE: Slightly skimped on the details here for brevity
return(VBasic.SyntaxFacts.IsValidIdentifier(name.ToString()) ? name : default(SyntaxToken?));
}
case VBasic.SyntaxKind.XmlBracketedName: {
// handles something like <a-a>
var xmlNameInferredFrom = (VBSyntax.XmlBracketedNameSyntax)input;
input = xmlNameInferredFrom.Name;
continue;
}
case VBasic.SyntaxKind.SimpleMemberAccessExpression:
case VBasic.SyntaxKind.DictionaryAccessExpression: {
var memberAccess = (VBSyntax.MemberAccessExpressionSyntax)input;
var receiver = memberAccess.Expression ?? conditionalAccessStack.Pop();
if (input.Kind() == VBasic.SyntaxKind.SimpleMemberAccessExpression)
{
// See if this is an identifier qualified with XmlElementAccessExpression or XmlDescendantAccessExpression
if (receiver != null)
{
switch (receiver.Kind())
{
case VBasic.SyntaxKind.XmlElementAccessExpression:
case VBasic.SyntaxKind.XmlDescendantAccessExpression: {
input = receiver;
continue;
}
}
}
}
conditionalAccessStack = null;
isNameDictionaryAccess = input.Kind() == VBasic.SyntaxKind.DictionaryAccessExpression;
input = memberAccess.Name;
continue;
}
case VBasic.SyntaxKind.XmlElementAccessExpression:
case VBasic.SyntaxKind.XmlAttributeAccessExpression:
case VBasic.SyntaxKind.XmlDescendantAccessExpression: {
var xmlAccess = (VBSyntax.XmlMemberAccessExpressionSyntax)input;
conditionalAccessStack.Clear();
input = xmlAccess.Name;
continue;
}
case VBasic.SyntaxKind.InvocationExpression: {
var invocation = (VBSyntax.InvocationExpressionSyntax)input;
var target = invocation.Expression ?? conditionalAccessStack.Pop();
if (target == null)
{
break;
}
if (invocation.ArgumentList == null || invocation.ArgumentList.Arguments.Count == 0)
{
input = target;
continue;
}
if (invocation.ArgumentList.Arguments.Count == 1)
{
// See if this is an indexed XmlElementAccessExpression or XmlDescendantAccessExpression
switch (target.Kind())
{
case VBasic.SyntaxKind.XmlElementAccessExpression:
case VBasic.SyntaxKind.XmlDescendantAccessExpression: {
input = target;
continue;
}
}
}
break;
}
case VBasic.SyntaxKind.ConditionalAccessExpression: {
var access = (VBSyntax.ConditionalAccessExpressionSyntax)input;
if (conditionalAccessStack == null)
{
conditionalAccessStack = new Stack <VBSyntax.ConditionalAccessExpressionSyntax>();
}
conditionalAccessStack.Push(access);
input = access.WhenNotNull;
continue;
}
}
return(null);
}
}
public static bool AlwaysHasBooleanTypeInCSharp(this VBSyntax.ExpressionSyntax node) => node.SkipIntoParens().IsKind(VBasic.SyntaxKind.AndAlsoExpression, VBasic.SyntaxKind.AndExpression, VBasic.SyntaxKind.OrElseExpression, VBasic.SyntaxKind.OrExpression, VBasic.SyntaxKind.NotExpression);
private static bool UnpackExpressionFromStatement(StatementSyntax statementSyntax, out ExpressionSyntax expression)
{
if (statementSyntax is ReturnStatementSyntax returnStmt)
{
expression = returnStmt.Expression;
}
else if (statementSyntax is YieldStatementSyntax yieldStmt)
{
expression = yieldStmt.Expression;
}
else
{
expression = null;
}
return(expression != null);
}
private async Task <ExpressionSyntax> ConvertIsOrIsNotExpressionArgAsync(VBSyntax.ExpressionSyntax binaryExpressionArg)
{
return((ExpressionSyntax)(await ConvertMyGroupCollectionPropertyGetWithUnderlyingFieldAsync(binaryExpressionArg)
?? await binaryExpressionArg.AcceptAsync(_triviaConvertingVisitor)));
}
public async Task <ExpressionSyntax> ConvertReferenceOrNothingComparisonOrNullAsync(VBSyntax.ExpressionSyntax exprNode, bool negateExpression = false)
{
if (!(exprNode is VBSyntax.BinaryExpressionSyntax node) ||
!node.IsKind(VBasic.SyntaxKind.IsExpression, VBasic.SyntaxKind.EqualsExpression, VBasic.SyntaxKind.IsNotExpression, VBasic.SyntaxKind.NotEqualsExpression))
{
return(null);
}
var notted =
node.IsKind(VBasic.SyntaxKind.IsNotExpression, VBasic.SyntaxKind.NotEqualsExpression) ||
negateExpression;
var isReferenceComparison = node.IsKind(VBasic.SyntaxKind.IsExpression, VBasic.SyntaxKind.IsNotExpression);
if (ArgComparedToNull(node) is {} vbOtherArg)
{
var csOtherArg = await ConvertIsOrIsNotExpressionArgAsync(vbOtherArg);
return(notted
? CommonConversions.NotNothingComparison(csOtherArg, isReferenceComparison)
: CommonConversions.NothingComparison(csOtherArg, isReferenceComparison));
}
if (isReferenceComparison)
{
var lhs = await ConvertIsOrIsNotExpressionArgAsync(node.Left);
var rhs = await ConvertIsOrIsNotExpressionArgAsync(node.Right);
var equalityCheck = new KnownMethod(nameof(System), nameof(Object), nameof(object.ReferenceEquals))
.Invoke(_visualBasicEqualityComparison.ExtraUsingDirectives,
ConvertTo(node.Left, lhs, SpecialType.System_Object), rhs);
return(notted
? SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, equalityCheck)
: equalityCheck);
}
return(null);
}
private ExpressionSyntax ConvertTo(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, SpecialType targetType)
{
return(_typeConversionAnalyzer.AddExplicitConversion(vbNode, csNode, forceTargetType: _semanticModel.Compilation.GetSpecialType(targetType)));
}
public static bool UnconvertedIsType(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax e, string fullTypeName, SemanticModel semanticModel)
{
return(semanticModel.GetTypeInfo(e).Type?.GetFullMetadataName() == fullTypeName);
}
/// <summary>
/// Returns true only if expressions static (i.e. doesn't reference the containing instance)
/// </summary>
public static bool IsDefinitelyStatic(this SemanticModel semanticModel, VBSyntax.ModifiedIdentifierSyntax vbName, VBSyntax.ExpressionSyntax vbInitValue)
{
var arrayBoundExpressions = vbName.ArrayBounds != null?vbName.ArrayBounds.Arguments.Select(a => a.GetExpression()) : Enumerable.Empty <VBSyntax.ExpressionSyntax>();
var expressions = vbInitValue.Yield().Concat(arrayBoundExpressions).Where(x => x != null).ToArray();
return(expressions.All(e => semanticModel.IsDefinitelyStatic(e)));
}
public (ExpressionSyntax lhs, ExpressionSyntax rhs) VbCoerceToString(VBSyntax.ExpressionSyntax vbLeft, ExpressionSyntax csLeft, TypeInfo lhsTypeInfo, VBSyntax.ExpressionSyntax vbRight, ExpressionSyntax csRight, TypeInfo rhsTypeInfo)
{
if (IsNonEmptyStringLiteral(vbLeft) || IsNonEmptyStringLiteral(vbRight))
{
return(csLeft, csRight);
}
return(VbCoerceToString(vbLeft, csLeft, lhsTypeInfo), VbCoerceToString(vbRight, csRight, rhsTypeInfo));
}
internal SyntaxTrivia ConvertTrivia(SyntaxTrivia t)
{
var switchExpr = t.RawKind;
/* TODO ERROR: Skipped RegionDirectiveTrivia */
switch (switchExpr)
{
case (int)CS.SyntaxKind.WhitespaceTrivia: {
return(VBFactory.WhitespaceTrivia(t.ToString()));
}
case (int)CS.SyntaxKind.EndOfLineTrivia: {
return(global::VisualBasicSyntaxFactory.VBEOLTrivia);
}
case (int)CS.SyntaxKind.SingleLineCommentTrivia: {
if (t.ToFullString().EndsWith("*/"))
{
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2, t.ToFullString().Length - 4))}"));
}
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2))}"));
}
case (int)CS.SyntaxKind.MultiLineCommentTrivia: {
if (t.ToFullString().EndsWith("*/"))
{
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2, t.ToFullString().Length - 4)).Replace(Constants.vbLf, "").Replace(Constants.vbCr, "")}"));
}
return(VBFactory.CommentTrivia($"'{ReplaceLeadingSlashes(t.ToFullString().Substring(2)).Replace(Constants.vbLf, "").Replace(Constants.vbCr, "")}"));
}
case (int)CS.SyntaxKind.DocumentationCommentExteriorTrivia: {
return(VBFactory.SyntaxTrivia(VB.SyntaxKind.CommentTrivia, "'''"));
}
case (int)CS.SyntaxKind.DisabledTextTrivia: {
if (TriviaDepth > 0)
{
return(VBFactory.DisabledTextTrivia(t.ToString().WithoutNewLines(' ')));
}
return(VBFactory.DisabledTextTrivia(t.ToString().ConsistentNewlines()));
}
case (int)CS.SyntaxKind.PreprocessingMessageTrivia: {
return(VBFactory.CommentTrivia($" ' {t}"));
}
case (int)CS.SyntaxKind.None: {
return(default(SyntaxTrivia));
}
}
/* TODO ERROR: Skipped EndRegionDirectiveTrivia */
/* TODO ERROR: Skipped RegionDirectiveTrivia */
CSS.StructuredTriviaSyntax StructuredTrivia = (CSS.StructuredTriviaSyntax)t.GetStructure();
Debug.Assert(StructuredTrivia != null, $"Found new type of non structured trivia {t.RawKind}");
var switchExpr1 = t.RawKind;
switch (switchExpr1)
{
case (int)CS.SyntaxKind.DefineDirectiveTrivia: {
CSS.DefineDirectiveTriviaSyntax DefineDirective = (CSS.DefineDirectiveTriviaSyntax)StructuredTrivia;
var Name = VBFactory.Identifier(DefineDirective.Name.ValueText);
VBS.ExpressionSyntax value = VBFactory.TrueLiteralExpression(global::VisualBasicSyntaxFactory.TrueKeyword);
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(WithConvertedTriviaFrom(VBFactory.ConstDirectiveTrivia(Name, value), DefineDirective), DefineDirective.EndOfDirectiveToken)
));
}
case (int)CS.SyntaxKind.UndefDirectiveTrivia: {
CSS.UndefDirectiveTriviaSyntax UndefineDirective = (CSS.UndefDirectiveTriviaSyntax)StructuredTrivia;
var Name = VBFactory.Identifier(UndefineDirective.Name.ValueText);
VBS.ExpressionSyntax value = global::VisualBasicSyntaxFactory.NothingExpression;
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(WithConvertedTriviaFrom(VBFactory.ConstDirectiveTrivia(Name, value), UndefineDirective), UndefineDirective.EndOfDirectiveToken)
));
}
case (int)CS.SyntaxKind.EndIfDirectiveTrivia: {
if (TriviaDepth > 0)
{
TriviaDepth -= 1;
return(VBFactory.CommentTrivia($"' TODO VB does not allow directives here, original statement {t.ToFullString().WithoutNewLines(' ')}"));
}
CSS.EndIfDirectiveTriviaSyntax EndIfDirective = (CSS.EndIfDirectiveTriviaSyntax)StructuredTrivia;
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.EndIfDirectiveTrivia().WithConvertedTrailingTriviaFrom(EndIfDirective.EndIfKeyword), EndIfDirective.EndOfDirectiveToken)
));
}
case (int)CS.SyntaxKind.ErrorDirectiveTrivia: {
CSS.ErrorDirectiveTriviaSyntax ErrorDirective = (CSS.ErrorDirectiveTriviaSyntax)StructuredTrivia;
return(VBFactory.CommentTrivia($"' TODO: Check VB does not support Error Directive Trivia, Original Directive {ErrorDirective.ToFullString()}"));
}
case (int)CS.SyntaxKind.IfDirectiveTrivia: {
if (t.Token.Parent?.AncestorsAndSelf().OfType <CSS.InitializerExpressionSyntax>().Any() == true)
{
TriviaDepth += 1;
}
CSS.IfDirectiveTriviaSyntax IfDirective = (CSS.IfDirectiveTriviaSyntax)StructuredTrivia;
string Expression1 = StringReplaceCondition(IfDirective.Condition.ToString());
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.IfDirectiveTrivia(global::VisualBasicSyntaxFactory.IfKeyword, VBFactory.ParseExpression(Expression1)).With(IfDirective.GetLeadingTrivia().ConvertTrivia(), IfDirective.Condition.GetTrailingTrivia().ConvertTrivia()), IfDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.ElifDirectiveTrivia: {
if (t.Token.Parent.AncestorsAndSelf().OfType <CSS.InitializerExpressionSyntax>().Any())
{
TriviaDepth += 1;
}
CSS.ElifDirectiveTriviaSyntax ELIfDirective = (CSS.ElifDirectiveTriviaSyntax)StructuredTrivia;
string Expression1 = StringReplaceCondition(ELIfDirective.Condition.ToString());
SyntaxToken IfOrElseIfKeyword;
if (t.IsKind(CS.SyntaxKind.ElifDirectiveTrivia))
{
IfOrElseIfKeyword = global::VisualBasicSyntaxFactory.ElseIfKeyword;
}
else
{
IfOrElseIfKeyword = global::VisualBasicSyntaxFactory.IfKeyword;
}
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.ElseIfDirectiveTrivia(IfOrElseIfKeyword, VBFactory.ParseExpression(Expression1))
.With(ELIfDirective.GetLeadingTrivia().ConvertTrivia(), ELIfDirective.Condition.GetTrailingTrivia().ConvertTrivia())
, ELIfDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.LineDirectiveTrivia: {
return(VBFactory.CommentTrivia($"' TODO: Check VB does not support Line Directive Trivia, Original Directive {t}"));
}
case (int)CS.SyntaxKind.ElseDirectiveTrivia: {
return(VBFactory.Trivia(WithTrailingEOL(VBFactory.ElseDirectiveTrivia().NormalizeWhitespace().WithConvertedTrailingTriviaFrom(((CSS.ElseDirectiveTriviaSyntax)StructuredTrivia).ElseKeyword))));
}
case (int)CS.SyntaxKind.EndRegionDirectiveTrivia: {
CSS.EndRegionDirectiveTriviaSyntax EndRegionDirective = (CSS.EndRegionDirectiveTriviaSyntax)StructuredTrivia;
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(VBFactory.EndRegionDirectiveTrivia(global::VisualBasicSyntaxFactory.HashToken, global::VisualBasicSyntaxFactory.EndKeyword, global::VisualBasicSyntaxFactory.RegionKeyword), EndRegionDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.PragmaWarningDirectiveTrivia: {
// Dim PragmaWarningDirectiveTrivia As CSS.PragmaWarningDirectiveTriviaSyntax = DirectCast(StructuredTrivia, CSS.PragmaWarningDirectiveTriviaSyntax)
// Dim ErrorList As New List(Of VBS.IdentifierNameSyntax)
// Dim TrailingTriviaStringBuilder As New StringBuilder
// For Each i As CSS.ExpressionSyntax In PragmaWarningDirectiveTrivia.ErrorCodes
// Dim ErrorCode As String = i.ToString
// If ErrorCode.IsInteger Then
// ErrorCode = $"CS_{ErrorCode}"
// End If
// ErrorList.Add(VBFactory.IdentifierName(ErrorCode))
// For Each Trivial As SyntaxTrivia In i.GetTrailingTrivia
// TrailingTriviaStringBuilder.Append(Trivial.ToString)
// Next
// Next
// Dim WarningDirectiveTrivia As VBS.DirectiveTriviaSyntax
// If PragmaWarningDirectiveTrivia.DisableOrRestoreKeyword.IsKind(CS.SyntaxKind.DisableKeyword) Then
// WarningDirectiveTrivia = VBFactory.DisableWarningDirectiveTrivia(ErrorList.ToArray)
// Else
// WarningDirectiveTrivia = VBFactory.EnableWarningDirectiveTrivia(ErrorList.ToArray)
// End If
// Return VBFactory.CommentTrivia($" ' TODO {WarningDirectiveTrivia.NormalizeWhitespace}{TrailingTriviaStringBuilder.ToString}")
return(default(SyntaxTrivia));
}
case (int)CS.SyntaxKind.RegionDirectiveTrivia: {
CSS.RegionDirectiveTriviaSyntax RegionDirective = (CSS.RegionDirectiveTriviaSyntax)StructuredTrivia;
var EndOfDirectiveToken = RegionDirective.EndOfDirectiveToken;
string NameString = $"\"{EndOfDirectiveToken.LeadingTrivia.ToString().Replace("\"", "")}\"";
var RegionDirectiveTriviaNode = VBFactory.RegionDirectiveTrivia(global::VisualBasicSyntaxFactory.HashToken, global::VisualBasicSyntaxFactory.RegionKeyword, VBFactory.StringLiteralToken(NameString, NameString)
).WithConvertedTrailingTriviaFrom(EndOfDirectiveToken);
return(VBFactory.Trivia(WithTrailingEOL(RegionDirectiveTriviaNode)));
}
case (int)CS.SyntaxKind.SingleLineDocumentationCommentTrivia: {
CSS.DocumentationCommentTriviaSyntax SingleLineDocumentationComment = (CSS.DocumentationCommentTriviaSyntax)StructuredTrivia;
var walker = new XMLVisitor();
walker.Visit(SingleLineDocumentationComment);
var xmlNodes = new List <VBS.XmlNodeSyntax>();
for (int i = 0, loopTo = SingleLineDocumentationComment.Content.Count - 1; i <= loopTo; i++)
{
var node = SingleLineDocumentationComment.Content[i];
if (!node.IsKind(CS.SyntaxKind.XmlText) && node.GetLeadingTrivia().Count > 0 && node.GetLeadingTrivia().First().IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia))
{
if (i < SingleLineDocumentationComment.Content.Count - 1)
{
var NextNode = SingleLineDocumentationComment.Content[i + 1];
if (!NextNode.IsKind(CS.SyntaxKind.XmlText) || NextNode.GetLeadingTrivia().Count == 0 || !NextNode.GetLeadingTrivia().First().IsKind(CS.SyntaxKind.DocumentationCommentExteriorTrivia))
{
xmlNodes.Add(VBFactory.XmlText(" ").WithLeadingTrivia(VBFactory.DocumentationCommentExteriorTrivia("'''")));
}
}
node = node.WithoutLeadingTrivia();
}
VBS.XmlNodeSyntax Item = (VBS.XmlNodeSyntax)node.Accept(walker);
xmlNodes.Add(Item);
}
var DocumentationCommentTrivia = VBFactory.DocumentationCommentTrivia(VBFactory.List(xmlNodes.ToArray()));
if (!DocumentationCommentTrivia.HasLeadingTrivia || !DocumentationCommentTrivia.GetLeadingTrivia()[0].IsKind(VB.SyntaxKind.DocumentationCommentExteriorTrivia))
{
DocumentationCommentTrivia = DocumentationCommentTrivia.WithLeadingTrivia(VBFactory.DocumentationCommentExteriorTrivia("''' "));
}
var _DocumentationComment = VBFactory.Trivia(DocumentationCommentTrivia.WithTrailingTrivia(VBFactory.EndOfLine("")));
return(_DocumentationComment);
}
case (int)CS.SyntaxKind.PragmaChecksumDirectiveTrivia: {
CSS.PragmaChecksumDirectiveTriviaSyntax PragmaChecksumDirective = (CSS.PragmaChecksumDirectiveTriviaSyntax)StructuredTrivia;
var Guid1 = VBFactory.ParseToken(PragmaChecksumDirective.Guid.Text.ToUpperInvariant());
var Bytes = VBFactory.ParseToken(PragmaChecksumDirective.Bytes.Text);
var ExternalSource = VBFactory.ParseToken(PragmaChecksumDirective.File.Text);
return(VBFactory.Trivia(WithAppendedTriviaFromEndOfDirectiveToken(
VBFactory.ExternalChecksumDirectiveTrivia(global::VisualBasicSyntaxFactory.HashToken, global::VisualBasicSyntaxFactory.ExternalChecksumKeyword, global::VisualBasicSyntaxFactory.OpenParenToken, ExternalSource, global::VisualBasicSyntaxFactory.CommaToken, Guid1, global::VisualBasicSyntaxFactory.CommaToken, Bytes, global::VisualBasicSyntaxFactory.CloseParenToken), PragmaChecksumDirective.EndOfDirectiveToken)));
}
case (int)CS.SyntaxKind.SkippedTokensTrivia: {
var Builder = new StringBuilder();
foreach (SyntaxToken tok in ((CSS.SkippedTokensTriviaSyntax)StructuredTrivia).Tokens)
{
Builder.Append(tok.ToString());
}
return(VBFactory.CommentTrivia($"' TODO: Error SkippedTokensTrivia '{Builder}'"));
}
case (int)CS.SyntaxKind.BadDirectiveTrivia: {
return(VBFactory.CommentTrivia($"' TODO: Skipped BadDirectiveTrivia"));
}
case (int)CS.SyntaxKind.ConflictMarkerTrivia: {
break;
}
case (int)CS.SyntaxKind.LoadDirectiveTrivia: {
break;
}
default: {
Debug.WriteLine(((VB.SyntaxKind)Conversions.ToUShort(t.RawKind)).ToString());
break;
}
}
throw new NotImplementedException($"t.Kind({(VB.SyntaxKind)Conversions.ToUShort(t.RawKind)}) Is unknown");
}
/// <summary>
/// Returns true only if expression is static (i.e. doesn't reference the containing instance)
/// </summary>
private static bool IsDefinitelyStatic(this SemanticModel semanticModel, VBSyntax.ExpressionSyntax e)
{
return(semanticModel.GetOperation(e).DescendantsAndSelf().OfType <IInstanceReferenceOperation>().Any() == false);
}
