public static Task <HandledEventsAnalysis> AnalyzeAsync(CommonConversions commonConversions, INamedTypeSymbol type, IMethodSymbol designerGeneratedInitializeComponentOrNull,
ILookup <ITypeSymbol, ITypeSymbol> typeToInheritors)
{
var initializeComponentLocationOrNull = designerGeneratedInitializeComponentOrNull?.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).OfType <MethodStatementSyntax>().OrderByDescending(m => m.Span.Length).Select(s => s.Parent.GetLocation()).FirstOrDefault();
return(new HandledEventsAnalyzer(commonConversions, type, initializeComponentLocationOrNull, typeToInheritors).AnalyzeAsync());
}
public async Task <SyntaxList <StatementSyntax> > CreateLocalsAsync(VBasic.VisualBasicSyntaxNode vbNode, IEnumerable <StatementSyntax> csNodes, HashSet <string> generatedNames, SemanticModel semanticModel)
{
var preDeclarations = new List <StatementSyntax>();
var postAssignments = new List <StatementSyntax>();
var additionalDeclarationInfo = GetDeclarations();
var newNames = additionalDeclarationInfo.ToDictionary(l => l.Id, l =>
NameGenerator.GetUniqueVariableNameInScope(semanticModel, generatedNames, vbNode, l.Prefix)
);
foreach (var additionalLocal in additionalDeclarationInfo)
{
var decl = CommonConversions.CreateVariableDeclarationAndAssignment(newNames[additionalLocal.Id],
additionalLocal.Initializer, additionalLocal.Type);
preDeclarations.Add(CS.SyntaxFactory.LocalDeclarationStatement(decl));
}
foreach (var additionalAssignment in GetPostAssignments())
{
var assign = CS.SyntaxFactory.AssignmentExpression(CS.SyntaxKind.SimpleAssignmentExpression, additionalAssignment.LeftHandSide, additionalAssignment.RightHandSide);
postAssignments.Add(CS.SyntaxFactory.ExpressionStatement(assign));
}
var statementsWithUpdatedIds = ReplaceNames(preDeclarations.Concat(csNodes).Concat(postAssignments), newNames);
return(CS.SyntaxFactory.List(statementsWithUpdatedIds));
}
private SyntaxList <StatementSyntax> AddLocalVariables(VBasic.VisualBasicSyntaxNode node)
{
_additionalLocals.PushScope();
IEnumerable <SyntaxNode> csNodes = _wrappedVisitor.Visit(node);
var additionalDeclarations = new List <StatementSyntax>();
if (_additionalLocals.Count() > 0)
{
var newNames = new Dictionary <string, string>();
csNodes = csNodes.Select(csNode => csNode.ReplaceNodes(csNode.GetAnnotatedNodes(AdditionalLocals.Annotation), (an, _) => {
var id = (an as IdentifierNameSyntax).Identifier.ValueText;
newNames[id] = NameGenerator.GetUniqueVariableNameInScope(_semanticModel, _generatedNames, node, _additionalLocals[id].Prefix);
return(SyntaxFactory.IdentifierName(newNames[id]));
})).ToList();
foreach (var additionalLocal in _additionalLocals)
{
var decl = CommonConversions.CreateVariableDeclarationAndAssignment(newNames[additionalLocal.Key], additionalLocal.Value.Initializer);
additionalDeclarations.Add(SyntaxFactory.LocalDeclarationStatement(decl));
}
}
_additionalLocals.PopScope();
return(SyntaxFactory.List(additionalDeclarations.Concat(csNodes)));
}
public async Task <ExpressionSyntax> ConvertNothingComparisonOrNullAsync(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);
}
ExpressionSyntax otherArgument;
if (node.Left.IsKind(VBasic.SyntaxKind.NothingLiteralExpression))
{
otherArgument = (ExpressionSyntax) await ConvertIsOrIsNotExpressionArgAsync(node.Right);
}
else if (node.Right.IsKind(VBasic.SyntaxKind.NothingLiteralExpression))
{
otherArgument = (ExpressionSyntax) await ConvertIsOrIsNotExpressionArgAsync(node.Left);
}
else
{
return(null);
}
var isReference = node.IsKind(VBasic.SyntaxKind.IsExpression, VBasic.SyntaxKind.IsNotExpression);
var notted = node.IsKind(VBasic.SyntaxKind.IsNotExpression, VBasic.SyntaxKind.NotEqualsExpression) || negateExpression;
return(notted ? CommonConversions.NotNothingComparison(otherArgument, isReference) : CommonConversions.NothingComparison(otherArgument, isReference));
}
public ClassDeclarationSyntax GenerateHelper()
{
if (!HasImports)
{
return(null);
}
var xAttributeList = SyntaxFactory.FieldDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.PrivateKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
CommonConversions.CreateVariableDeclarationAndAssignment(
"namespaceAttributes", SyntaxFactory.InitializerExpression(
CSSyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
from x in _xNamespaceFields
let fieldIdentifierName = SyntaxFactory.IdentifierName(x.Declaration.Variables.Single().Identifier)
let namespaceNameExpression = SyntaxFactory.MemberAccessExpression(CSSyntaxKind.SimpleMemberAccessExpression, fieldIdentifierName, SyntaxFactory.IdentifierName("NamespaceName"))
let attributeNameExpression = fieldIdentifierName.IsEquivalentTo(DefaultIdentifierName) ? CommonConversions.Literal("xmlns") : BuildXmlnsAttributeName(fieldIdentifierName)
let arguments = SyntaxFactory.Argument(attributeNameExpression).Yield().Concat(SyntaxFactory.Argument(namespaceNameExpression))
select SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName("XAttribute")).WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))))),
SyntaxFactory.ArrayType(SyntaxFactory.IdentifierName("XAttribute"), SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression()))))));
var boilerplate = SyntaxFactory.ParseStatement(@"
TContainer Apply<TContainer>(TContainer x) where TContainer : XContainer
{
foreach (var d in x.Descendants()) {
foreach (var n in namespaceAttributes) {
var a = d.Attribute(n.Name);
if (a != null && a.Value == n.Value) {
a.Remove();
}
}
}
x.Add(namespaceAttributes);
return x;
}") as LocalFunctionStatementSyntax;
var applyMethod = SyntaxFactory.MethodDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
boilerplate.ReturnType,
null,
boilerplate.Identifier,
boilerplate.TypeParameterList,
boilerplate.ParameterList,
boilerplate.ConstraintClauses,
boilerplate.Body,
boilerplate.ExpressionBody);
return(SyntaxFactory.ClassDeclaration(
SyntaxFactory.List <AttributeListSyntax>(),
SyntaxFactory.TokenList(SyntaxFactory.Token(CSSyntaxKind.InternalKeyword), SyntaxFactory.Token(CSSyntaxKind.StaticKeyword)),
HelperClassUniqueIdentifierName.Identifier,
null, null,
SyntaxFactory.List <TypeParameterConstraintClauseSyntax>(),
SyntaxFactory.List(_xNamespaceFields.Concat <MemberDeclarationSyntax>(xAttributeList).Concat(applyMethod))
));
}
private HandledEventsAnalyzer(CommonConversions commonConversions, INamedTypeSymbol type, Location initializeComponentLocationOrNull, ILookup <ITypeSymbol, ITypeSymbol> typeToInheritors)
{
_commonConversions = commonConversions;
_semanticModel = commonConversions.SemanticModel;
_type = type;
_initializeComponentLocationOrNull = initializeComponentLocationOrNull;
_typeToInheritors = typeToInheritors;
}
public MethodBodyVisitor(SemanticModel semanticModel, VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> nodesVisitor, Stack <string> withBlockTempVariableNames, TriviaConverter triviaConverter)
{
this._semanticModel = semanticModel;
this._nodesVisitor = nodesVisitor;
this._withBlockTempVariableNames = withBlockTempVariableNames;
CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(this, triviaConverter);
CommonConversions = new CommonConversions(semanticModel, _nodesVisitor);
}
public MethodBodyVisitor(VBasic.VisualBasicSyntaxNode methodNode, SemanticModel semanticModel,
VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> nodesVisitor,
Stack <string> withBlockTempVariableNames, HashSet <string> extraUsingDirectives,
TriviaConverter triviaConverter)
{
_methodNode = methodNode;
this._semanticModel = semanticModel;
this._nodesVisitor = nodesVisitor;
this._withBlockTempVariableNames = withBlockTempVariableNames;
_extraUsingDirectives = extraUsingDirectives;
CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(this, triviaConverter);
CommonConversions = new CommonConversions(semanticModel, _nodesVisitor);
}
public MethodBodyVisitor(VBasic.VisualBasicSyntaxNode methodNode, SemanticModel semanticModel,
VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> nodesVisitor, CommonConversions commonConversions,
Stack <string> withBlockTempVariableNames, HashSet <string> extraUsingDirectives,
AdditionalLocals additionalLocals, TriviaConverter triviaConverter)
{
_methodNode = methodNode;
_semanticModel = semanticModel;
_nodesVisitor = nodesVisitor;
CommonConversions = commonConversions;
_withBlockTempVariableNames = withBlockTempVariableNames;
_extraUsingDirectives = extraUsingDirectives;
var byRefParameterVisitor = new ByRefParameterVisitor(this, additionalLocals, semanticModel, _generatedNames);
CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(byRefParameterVisitor, triviaConverter);
}
/// <summary>
/// Make winforms designer work: https://github.com/icsharpcode/CodeConverter/issues/321
/// </summary>
public SyntaxList <StatementSyntax> GetPostAssignmentStatements(Microsoft.CodeAnalysis.VisualBasic.Syntax.AssignmentStatementSyntax node, ISymbol potentialPropertySymbol)
{
if (CommonConversions.MustInlinePropertyWithEventsAccess(node, potentialPropertySymbol))
{
var fieldName = SyntaxFactory.IdentifierName("_" + potentialPropertySymbol.Name);
var handledMethods = _handledMethodsFromPropertyWithEventName[potentialPropertySymbol.Name].ToArray();
if (handledMethods.Any())
{
var postAssignmentStatements = handledMethods.SelectMany(h =>
h.GetPostInitializationStatements(potentialPropertySymbol.Name, fieldName));
return(SyntaxFactory.List(postAssignmentStatements));
}
}
return(SyntaxFactory.List <StatementSyntax>());
}
public MethodBodyExecutableStatementVisitor(VBasic.VisualBasicSyntaxNode methodNode, SemanticModel semanticModel,
CommentConvertingVisitorWrapper <CSharpSyntaxNode> expressionVisitor, CommonConversions commonConversions,
Stack <ExpressionSyntax> withBlockLhs, HashSet <string> extraUsingDirectives,
AdditionalLocals additionalLocals, MethodsWithHandles methodsWithHandles,
TriviaConverter triviaConverter)
{
_methodNode = methodNode;
_semanticModel = semanticModel;
_expressionVisitor = expressionVisitor;
CommonConversions = commonConversions;
_withBlockLhs = withBlockLhs;
_extraUsingDirectives = extraUsingDirectives;
_methodsWithHandles = methodsWithHandles;
var byRefParameterVisitor = new ByRefParameterVisitor(this, additionalLocals, semanticModel, _generatedNames);
CommentConvertingVisitor = new CommentConvertingMethodBodyVisitor(byRefParameterVisitor, triviaConverter);
}
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 BuildXmlnsAttributeName(IdentifierNameSyntax fieldIdentifierName)
{
var xmlns = SyntaxFactory.MemberAccessExpression(CSSyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("XNamespace"), SyntaxFactory.IdentifierName("Xmlns"));
return(SyntaxFactory.BinaryExpression(CSSyntaxKind.AddExpression, xmlns, CommonConversions.Literal(fieldIdentifierName.Identifier.ValueText)));
}
public LambdaConverter(CommonConversions commonConversions, SemanticModel semanticModel)
{
CommonConversions = commonConversions;
_semanticModel = semanticModel;
_solution = CommonConversions.Document.Project.Solution;
}
public QueryConverter(CommonConversions commonConversions, CommentConvertingVisitorWrapper triviaConvertingVisitor)
{
CommonConversions = commonConversions;
_triviaConvertingVisitor = triviaConvertingVisitor;
}
public QueryConverter(CommonConversions commonConversions, SemanticModel semanticModel, CommentConvertingVisitorWrapper triviaConvertingExpressionVisitor)
{
CommonConversions = commonConversions;
_semanticModel = semanticModel;
_triviaConvertingVisitor = triviaConvertingExpressionVisitor;
}
public QueryConverter(CommonConversions commonConversions, CommentConvertingVisitorWrapper <CSharpSyntaxNode> triviaConvertingVisitor)
{
CommonConversions = commonConversions;
_triviaConvertingVisitor = triviaConvertingVisitor;
}
private async Task <SyntaxList <StatementSyntax> > AddLocalVariablesAsync(VBasic.VisualBasicSyntaxNode node, VBasic.SyntaxKind exitableType = default, bool isBreakableInCs = false)
{
_additionalLocals.PushScope(exitableType, isBreakableInCs);
try {
var convertedStatements = await _wrappedVisitor.Visit(node);
var withLocals = await _additionalLocals.CreateLocalsAsync(node, convertedStatements, _generatedNames, _semanticModel);
var allStatements = _additionalLocals.CreateStatements(node, withLocals, _generatedNames, _semanticModel);
if (isBreakableInCs && exitableType == VBasic.SyntaxKind.TryKeyword)
{
var doOnce = SyntaxFactory.DoStatement(SyntaxFactory.Block(allStatements), CommonConversions.Literal(false));
allStatements = SyntaxFactory.SingletonList <StatementSyntax>(doOnce);
}
return(allStatements);
} finally {
_additionalLocals.PopScope();
}
}
