public static ArgumentListSyntax GetParentInvocationArguments(
this MemberAccessExpressionSyntax memberAccess,
ExceptionSyntaxDetails details, int numArgumentsRequired,
Func <ArgumentSyntax, int, bool> check = null)
{
if (details == null)
{
throw new ArgumentNullException(nameof(details));
}
if (memberAccess?.Parent is InvocationExpressionSyntax invocation &&
invocation.ArgumentList?.Arguments.Count == numArgumentsRequired)
{
for (int i = 0; i < invocation.ArgumentList.Arguments.Count; i++)
{
if (check != null && !check(invocation.ArgumentList.Arguments[i], i))
{
details.SetInconclusive(invocation.ArgumentList.Arguments[i]?.ToString());
return(null);
}
}
return(invocation.ArgumentList);
}
details.SetInconclusive(memberAccess?.ToString());
return(null);
}
public static ArgumentListSyntax TransformParentInvocationArguments(
this MemberAccessExpressionSyntax memberAccess,
ExceptionSyntaxDetails details, int numArgumentsRequired,
Func <ArgumentSyntax, int, ArgumentSyntax> transform
)
{
if (details == null)
{
throw new ArgumentNullException(nameof(details));
}
if (transform == null)
{
throw new ArgumentNullException(nameof(transform));
}
if (memberAccess?.Parent is InvocationExpressionSyntax invocation &&
invocation.ArgumentList?.Arguments.Count == numArgumentsRequired)
{
var result = new SeparatedSyntaxList <ArgumentSyntax>();
for (int i = 0; i < invocation.ArgumentList.Arguments.Count; i++)
{
var transformed = transform(invocation.ArgumentList.Arguments[i], i);
if (transformed == null)
{
details.SetInconclusive(invocation.ArgumentList.Arguments[i]?.ToString());
return(null);
}
result = result.Add(transformed);
}
return(SyntaxFactory.ArgumentList(result));
}
details.SetInconclusive(memberAccess?.ToString());
return(null);
}
private bool TryMemberExpression(MemberAccessExpressionSyntax memberAccessExpression,
IDom newItem,
SemanticModel model,
ref object value,
ref LiteralKind literalKind,
ref string constantIdentifier)
{
if (memberAccessExpression == null)
{
return(false);
}
literalKind = LiteralKind.MemberAccess;
// If this is legal code, this is a constant or an enum
var constant = model.GetConstantValue(memberAccessExpression);
if (constant.HasValue)
{
constantIdentifier = memberAccessExpression.ToString();
value = constant.Value;
}
else
{
constantIdentifier = memberAccessExpression.ToFullString();
value = memberAccessExpression.ToFullString();
}
return(true);
}
public bool IsEligible(MemberAccessExpressionSyntax node)
{
var nodeString = node.ToString();
var nodeNameString = node.Name.ToString();
return(nodeString.Contains("Arg") && (nodeNameString.Contains("Matches") || nodeString.Contains(".List.ContainsAll")));
}
public SyntaxNode Visit(MemberAccessExpressionSyntax node)
{
var nodeString = node.ToString();
nodeString = Regex.Replace(nodeString, "Arg(<[a-zA-Z0-9,_. <>\\[\\]]+>).Is.Anything", "It.IsAny$1()");
nodeString = Regex.Replace(nodeString, "Arg(<[a-zA-Z0-9,_. <>\\[\\]]+>).Is.TypeOf", "It.IsAny$1()");
return(SyntaxFactory.ParseExpression(nodeString));
}
private static string[] ExtractPath(MemberAccessExpressionSyntax expression)
{
var path = expression.ToString().Split(".");
return(path
.Skip(1) // skipping variable name e.g. 'result'
.ToArray());
}
public bool IsEligible(MemberAccessExpressionSyntax node)
{
var nodeString = node.ToString();
var nodeNameString = node.Name.ToString();
return(nodeString.Contains("Arg") &&
(nodeNameString.Contains("Anything") || nodeNameString.Contains("TypeOf")));
}
public SyntaxNode Visit(MemberAccessExpressionSyntax node)
{
var nodeString = node.ToString();
nodeString = Regex.Replace(nodeString, "Arg(<[a-zA-Z0-9,_ <>\\[\\]]+>)(.*)Matches", "It.Is$1", RegexOptions.Singleline);
nodeString = Regex.Replace(nodeString, "Arg(<[a-zA-Z0-9,_ <>\\[\\]]+>).List.ContainsAll", "It.IsIn$1", RegexOptions.Singleline);
return(SyntaxFactory.ParseExpression(nodeString));
}
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
if (_targetPatternRegEx.Match(node.ToString()).Success)
{
RecordMatchAndContext(node, BlockType.None);
}
base.VisitMemberAccessExpression(node);
}
public bool IsEligible(MemberAccessExpressionSyntax node)
{
var nodeString = node.ToString();
var nodeNameString = node.Name.ToString();
return(nodeString.Contains("Arg") &&
(nodeNameString.Contains("Equal") || nodeNameString.Contains("Same") ||
nodeNameString.Contains("Null")));
}
public SyntaxNode Visit(MemberAccessExpressionSyntax node)
{
var nodeString = node.ToString();
nodeString = Regex.Replace(nodeString, "Arg(<[a-zA-Z0-9,_ <>\\[\\]]+>).Is.Equal", "It.IsIn");
nodeString = Regex.Replace(nodeString, "Arg(<[a-zA-Z0-9,_ <>\\[\\]]+>).Is.Same", "It.IsIn");
nodeString = Regex.Replace(nodeString, "Arg<([a-zA-Z0-9,_ <>\\[\\]]+)>.Is.Null", "It.IsIn(($1)null)");
nodeString = Regex.Replace(nodeString, "Arg<([a-zA-Z0-9,_ <>\\[\\]]+)>.Is.NotNull", "It.Is<$1>(a => a != null)");
return(SyntaxFactory.ParseExpression(nodeString));
}
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
base.VisitMemberAccessExpression(node);
var isInsideMethod = Helpers.IsInsideMethod(node);
var isInsideMemberAccess = Helpers.IsInsideMemberAccessExpression(node);
var isValidParent = !isInsideMethod.result && !isInsideMemberAccess.result;
if (isValidParent)
{
IdentifierNames.Add(node.ToString());
}
}
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
// check if access to DMA property
var identifiers = node.RecursiveFlatIdentifiers();
if (identifiers.Any() && identifiers[0].ToString() == "SOC")
{
var dmaType = TypeResolver.ResolveType(identifiers[0]);
Expression = new IdentifierExpressionCPPModel()
{
Identifier = $"{dmaType.Namespace}_{dmaType.Name}_{identifiers.Last().Identifier}"
};
return;
}
if (BuiltInValues.IsBuiltInValue(node.ToString()))
{
var type = TypeResolver.ResolveType(node);
if (type == typeof(char))
{
Expression = new LiteralExpressionCPPModel()
{
Value = $"'{BuiltInValues.BuiltInValue(node.ToString())}'"
};
}
else
{
Expression = new LiteralExpressionCPPModel()
{
Value = BuiltInValues.BuiltInValue(node.ToString()).ToString()
};
}
return;
}
Unsupported(node, "Unsupported member access expression");
}
public static ExpressionSyntax MakeCompilerHappy(MemberAccessExpressionSyntax member, string methodName)
{
var str = member.ToString();
VariableCount.GetOrAdd(methodName, -1);
VariableCount[methodName]++;
var count = VariableCount[methodName];
str = $"var variableToMakeCompilerHappy{(count == 0 ? "" : count.ToString())} = " + str;
var statement = SyntaxFactory.ParseExpression(str);
return(statement);
}
public static ContractCategory GetContractCategory(this MemberAccessExpressionSyntax expressionSyntax)
{
var parts = expressionSyntax?.ToString()?.Split('.').Reverse().Take(2).ToArray();
if (parts?.Length != 2 || (parts[1] != "Contract"))
{
return(ContractCategory.Unknown);
}
ContractCategory result;
return(Enum.TryParse(parts[0], out result) ? result : ContractCategory.Unknown);
}
public override string?GetDefaultValue(IPropertySymbol propertySymbol)
{
var declaration = propertySymbol.DeclaringSyntaxReferences.First();
var propertyDeclaration = declaration.GetSyntax() as PropertyStatementSyntax;
if (propertyDeclaration?.Initializer is null)
{
return(null);
}
return(propertyDeclaration.Initializer.Value switch
{
LiteralExpressionSyntax s => s.Token.ValueText,
ObjectCreationExpressionSyntax s => s.ToString(),
MemberAccessExpressionSyntax s => s.ToString(),
_ => $"Type not handled: {propertyDeclaration.Initializer.Value.GetType()}"
});
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
SyntaxNode r_node = node;
if (node.IsKind(SyntaxKind.SimpleMemberAccessExpression) && node.ToString() == "ById.OnLeft")
{
var p = node.HasParent<ArgumentSyntax, ArgumentListSyntax, InvocationExpressionSyntax, EqualsValueClauseSyntax, VariableDeclaratorSyntax>();
if (p == null)
{
}
else
{
var byId = SyntaxFactory.ParseExpression("\"#" + p.Identifier.Text + "\"");
//var argById = SyntaxFactory.Argument(byId);
r_node = byId;
}
}
return r_node;
}
private void Initialize(int depth, MemberAccessExpressionSyntax memberAccessExpressionSyntax,
IPropertySymbol propertySymbol, SemanticModel semanticModel)
{
Depth = depth;
IsProperty = true;
InvocationString = memberAccessExpressionSyntax.ToString();
var containingNode = memberAccessExpressionSyntax.Ancestors().OfType <StatementSyntax>().FirstOrDefault();
OwnerStatementString = containingNode?.ToString();
var objectAccessedSyntax = memberAccessExpressionSyntax.Expression; // .ToString() => var name
var objectAccessedSymbol = semanticModel.GetSymbolInfo(objectAccessedSyntax).Symbol;
var objectAccessedTypeSymbol = semanticModel.GetTypeInfo(objectAccessedSyntax).Type;
MemberOwnerType = new TypeDescriptor(objectAccessedTypeSymbol);
MemberName = propertySymbol.Name;
ReturnType = new TypeDescriptor(propertySymbol.Type);
var containingTypeSymbol = propertySymbol.ContainingType;
ContainingType = new TypeDescriptor(containingTypeSymbol);
PropertyDeclarationSyntax = SymbolHelper.GetSyntaxReferences(memberAccessExpressionSyntax, semanticModel)
.FirstOrDefault()
?.GetSyntax() as PropertyDeclarationSyntax;
var assignment = memberAccessExpressionSyntax.Ancestors().OfType <AssignmentExpressionSyntax>().FirstOrDefault();
if (assignment != null && assignment.Left.DescendantNodesAndSelf().Contains(memberAccessExpressionSyntax))
{
// is a set property
IsPropertySetter = true;
}
else
{
// is a get property
}
}
private static bool IsIssue(MemberAccessExpressionSyntax syntaxNode) => syntaxNode.ToString() == GuidNewGuidInvocation;
public static bool IsCollectionSizeExpression(this MemberAccessExpressionSyntax node) => node.ToString() == "Has.Length.EqualTo" || node.ToString() == "Has.Count.EqualTo";
bool ConditionContainsNullCheck(ExpressionSyntax condition, ExpressionSyntax identifierToCheck)
{
var identifierNameToCheck = identifierToCheck as IdentifierNameSyntax;
var memberAccessExpressionToCheck = identifierToCheck as MemberAccessExpressionSyntax;
return(condition.DescendantNodesAndSelf().Any(n =>
{
var binaryExpr = n as BinaryExpressionSyntax;
if (binaryExpr != null)
{
IdentifierNameSyntax identifierName = binaryExpr.Left as IdentifierNameSyntax;
if ((identifierName != null) && (identifierNameToCheck != null) && (identifierName.Identifier.ValueText == identifierNameToCheck.Identifier.ValueText))
{
return binaryExpr.IsKind(SyntaxKind.IsNotExpression) && binaryExpr.Right.IsKind(SyntaxKind.NothingLiteralExpression);
}
MemberAccessExpressionSyntax memberAccessExpressionSyntax = binaryExpr.Left as MemberAccessExpressionSyntax;
if ((memberAccessExpressionSyntax != null) && (memberAccessExpressionToCheck != null) && (memberAccessExpressionSyntax.ToString() == identifierToCheck.ToString()))
{
return binaryExpr.IsKind(SyntaxKind.IsNotExpression) && binaryExpr.Right.IsKind(SyntaxKind.NothingLiteralExpression);
}
identifierName = binaryExpr.Right as IdentifierNameSyntax;
if ((identifierName != null) && (identifierNameToCheck != null) && (identifierName.Identifier.ValueText == identifierNameToCheck.Identifier.ValueText))
{
return binaryExpr.IsKind(SyntaxKind.IsNotExpression) && binaryExpr.Left.IsKind(SyntaxKind.NothingLiteralExpression);
}
memberAccessExpressionSyntax = binaryExpr.Right as MemberAccessExpressionSyntax;
if ((memberAccessExpressionSyntax != null) && (memberAccessExpressionToCheck != null) && (memberAccessExpressionSyntax.ToString() == identifierToCheck.ToString()))
{
return binaryExpr.IsKind(SyntaxKind.IsNotExpression) && binaryExpr.Left.IsKind(SyntaxKind.NothingLiteralExpression);
}
}
return false;
}));
}
/// <summary>
/// メンバーアクセス式構文のTypeScript変換
/// </summary>
/// <param name="condition">ExpressionSyntaxインスタンス</param>
/// <param name="localDeclarationStatements">ローカル変数リスト</param>
/// <returns>TypeScriptに変換した文字列</returns>
private string ConvertExpression(MemberAccessExpressionSyntax condition, List <string> localDeclarationStatements)
{
var result = condition.ToString();
if (condition.Expression is IdentifierNameSyntax == false)
{
result = $"{GetExpression(condition.Expression, localDeclarationStatements)}{condition.OperatorToken}";
result += condition.Name;
}
// メソッドをTypeScript用に置換え
result = AnalyzeUtility.ReplaceMethodName(result);
// thisをつけるかの判定
var targetCondition = condition as ExpressionSyntax;
if (condition.Expression is ElementAccessExpressionSyntax eaes)
{
targetCondition = eaes.Expression;
}
if (!IsLocalDeclarationStatement(targetCondition, localDeclarationStatements))
{
if (!result.StartsWith("this.", StringComparison.CurrentCulture))
{
return("this." + result);
}
}
// 内部クラスのクラス名変更
if (condition.Expression is IdentifierNameSyntax identifier)
{
var identifierName = identifier.Identifier.ValueText;
// ローカルフィールドの場合はそのまま返す
if (localDeclarationStatements.Contains(identifierName))
{
return(result);
}
var classObject = ClassObject.GetInstance();
// 別クラスの場合はクラス名置換えを実施
var otherClassNames = new List <string>()
{
identifierName,
condition.ToString(),
$"{classObject.ProcessClassName}.{identifierName}"
};
foreach (var className in otherClassNames)
{
if (classObject.RenameClasseNames.Keys.Contains(className))
{
result = classObject.RenameClasseNames[className];
if (className.StartsWith($"{classObject.ProcessClassName}.", StringComparison.CurrentCulture) && condition.Name.ToString() != identifierName && classObject.ProcessClassName != identifierName)
{
result += $".{condition.Name}";
}
return(result);
}
}
// クラスメンバの場合はそのまま返す
var myMethodNames = new List <string>()
{
identifierName,
condition.Name.ToString()
};
foreach (var methodName in myMethodNames)
{
if (classObject.StaticMembers.Where(item => item.Key == classObject.ProcessClassName).
Any(item => item.Value.Contains(methodName)))
{
return(result);
}
}
}
return(result);
}
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
Value = node.ToString();
//base.VisitMemberAccessExpression(node);
}
