/// <summary>Handles the specified expression.</summary>
/// <param name="castExpression">As expression.</param>
/// <param name="scopeParameters">The parameters.</param>
/// <returns>Returns the string.</returns>
public ExpressionDescriptor Handle(ICastExpression castExpression, Dictionary<string, string> scopeParameters)
{
var operand = castExpression.Op;
if (operand == null)
{
return null;
}
var type = castExpression.TargetType;
if (type == null)
{
return null;
}
var expressionDescriptor = ExpressionTemplateBuilder.Handle(operand, scopeParameters);
if (expressionDescriptor == null)
{
return null;
}
var result = new ExpressionDescriptor
{
Template = string.Format("({0}){1}", type.GetText(), expressionDescriptor.Template)
};
foreach (var variable in expressionDescriptor.TemplateVariables)
{
result.TemplateVariables[variable.Key] = variable.Value;
}
return result;
}
/// <summary>Handles the specified expression.</summary>
/// <param name="asExpression">As expression.</param>
/// <param name="scopeParameters">The parameters.</param>
/// <returns>Returns the string.</returns>
public ExpressionDescriptor Handle(IAsExpression asExpression, Dictionary<string, string> scopeParameters)
{
var operand = asExpression.Operand;
if (operand == null)
{
return null;
}
var type = asExpression.TypeOperand;
if (type == null)
{
return null;
}
var expressionDescriptor = ExpressionTemplateBuilder.Handle(operand, scopeParameters);
if (expressionDescriptor == null)
{
return null;
}
var result = new ExpressionDescriptor
{
Template = string.Format("{0} {1} {2}", expressionDescriptor.Template, asExpression.OperatorSign.GetTokenType().TokenRepresentation, type.GetText())
};
foreach (var variable in expressionDescriptor.TemplateVariables)
{
result.TemplateVariables[variable.Key] = variable.Value;
}
return result;
}
/// <summary>Handles the specified expression.</summary>
/// <param name="parenthesizedExpression">The invocation expression.</param>
/// <param name="statementParameters">The parameters.</param>
/// <returns>Returns the string.</returns>
public ExpressionDescriptor Handle(IParenthesizedExpression parenthesizedExpression, Dictionary<string, string> statementParameters)
{
var expression = parenthesizedExpression.Expression;
if (expression == null)
{
return null;
}
var statement = ExpressionTemplateBuilder.Handle(expression, statementParameters);
if (statement == null)
{
return null;
}
var result = new ExpressionDescriptor
{
Template = string.Format("({0})", statement.Template)
};
foreach (var variable in statement.TemplateVariables)
{
result.TemplateVariables[variable.Key] = variable.Value;
}
return result;
}
/// <summary>Handles the specified expression.</summary>
/// <param name="unaryOperatorExpression">The invocation expression.</param>
/// <param name="scopeParameters">The parameters.</param>
/// <returns>Returns the string.</returns>
public ExpressionDescriptor Handle(IUnaryOperatorExpression unaryOperatorExpression, Dictionary<string, string> scopeParameters)
{
var left = unaryOperatorExpression.Operand;
if (left == null)
{
return null;
}
var statement = ExpressionTemplateBuilder.Handle(left, scopeParameters);
if (statement == null)
{
return null;
}
var result = new ExpressionDescriptor
{
Template = string.Format("{0}{1}", unaryOperatorExpression.OperatorSign.GetTokenType().TokenRepresentation, statement.Template)
};
foreach (var variable in statement.TemplateVariables)
{
result.TemplateVariables[variable.Key] = variable.Value;
}
return result;
}
/// <summary>Handles the specified expression.</summary>
/// <param name="thisExpression">The invoked expression.</param>
/// <param name="statementParameters">The parameters.</param>
/// <returns>Returns the string.</returns>
public ExpressionDescriptor Handle(IThisExpression thisExpression, Dictionary<string, string> statementParameters)
{
var name = thisExpression.Type().GetPresentableName(thisExpression.Language).Replace("<", string.Empty).Replace(">", string.Empty).Replace(".", string.Empty);
var result = new ExpressionDescriptor
{
Template = "$" + name + "$"
};
result.TemplateVariables[name] = string.Format("variableOfType(\"{0}\")", thisExpression.Type().GetLongPresentableName(thisExpression.Language));
return result;
}
/// <summary>Handles the specified expression.</summary>
/// <param name="binaryExpression">The invocation expression.</param>
/// <param name="statementParameters">The parameters.</param>
/// <returns>Returns the string.</returns>
public ExpressionDescriptor Handle(IBinaryExpression binaryExpression, Dictionary<string, string> statementParameters)
{
var left = binaryExpression.LeftOperand;
if (left == null)
{
return null;
}
var right = binaryExpression.RightOperand;
if (right == null)
{
return null;
}
var leftStatement = ExpressionTemplateBuilder.Handle(left, statementParameters);
if (leftStatement == null)
{
return null;
}
var rightStatement = ExpressionTemplateBuilder.Handle(right, statementParameters);
if (rightStatement == null)
{
return null;
}
var result = new ExpressionDescriptor
{
Template = string.Format("{0} {1} {2}", leftStatement.Template, binaryExpression.OperatorSign.GetTokenType().TokenRepresentation, rightStatement.Template)
};
foreach (var variable in rightStatement.TemplateVariables)
{
result.TemplateVariables[variable.Key] = variable.Value;
}
foreach (var variable in leftStatement.TemplateVariables)
{
result.TemplateVariables[variable.Key] = variable.Value;
}
return result;
}
/// <summary>Handles the specified expression.</summary>
/// <param name="invocationExpression">The invocation expression.</param>
/// <param name="statementParameters">The parameters.</param>
/// <returns>Returns the string.</returns>
public ExpressionDescriptor Handle(IInvocationExpression invocationExpression, Dictionary<string, string> statementParameters)
{
var invokedExpression = invocationExpression.InvokedExpression as IReferenceExpression;
if (invokedExpression == null)
{
return null;
}
var result = new ExpressionDescriptor();
var qualifierExpression = invokedExpression.QualifierExpression;
if (qualifierExpression != null)
{
var descriptor = ExpressionTemplateBuilder.Handle(qualifierExpression, statementParameters);
if (descriptor != null)
{
result.Template = descriptor.Template;
foreach (var variable in descriptor.TemplateVariables)
{
result.TemplateVariables[variable.Key] = variable.Value;
}
}
else
{
result.Template += qualifierExpression.GetText();
}
}
string variableName;
if (!statementParameters.TryGetValue("VariableName", out variableName))
{
variableName = string.Empty;
}
if (!string.IsNullOrEmpty(result.Template))
{
result.Template += ".";
}
result.Template += invokedExpression.NameIdentifier.GetText() + "(";
var index = 0;
foreach (var argument in invocationExpression.Arguments)
{
var parameter = argument.MatchingParameter;
if (parameter == null)
{
continue;
}
var parameterName = parameter.Element.ShortName;
if (index > 0)
{
result.Template += ", ";
}
index++;
var argumentText = argument.GetText();
if (argumentText == variableName)
{
result.Template += "$VariableName$";
continue;
}
/*
if (argument.Value.IsConstantValue())
{
var constantValue = argument.Value.ConstantValue;
result.Template += "$" + parameterName + "$";
string s;
if (constantValue.IsPureNull(argument.Language))
{
s = "null";
}
else
{
s = constantValue.Value.ToString().Replace(",", ",").Replace(",", """);
if (constantValue.IsString())
{
s = "\"" + s + "\"";
}
}
result.TemplateVariables[parameterName] = "c:" + s;
continue;
}
*/
result.Template += "$" + parameterName + "$";
result.TemplateVariables[parameterName] = string.Empty;
}
result.Template += ")";
return result;
}
/// <summary>Handles the specified expression.</summary>
/// <param name="creationExpression">The invocation expression.</param>
/// <param name="statementParameters">The parameters.</param>
/// <returns>Returns the string.</returns>
public ExpressionDescriptor Handle(IObjectCreationExpression creationExpression, Dictionary<string, string> statementParameters)
{
string variableName;
if (!statementParameters.TryGetValue("VariableName", out variableName))
{
variableName = string.Empty;
}
var typeName = creationExpression.TypeName;
if (typeName == null)
{
return null;
}
var result = new ExpressionDescriptor
{
Template = creationExpression.NewKeyword.GetTokenType().TokenRepresentation + " "
};
var qualifiedName = string.Empty;
var resolveResult = typeName.Reference.Resolve();
if (resolveResult.IsValid())
{
var declaredElement = resolveResult.DeclaredElement;
var typeElement = declaredElement as ITypeElement;
if (typeElement != null)
{
qualifiedName = typeElement.ShortName;
var ns = typeElement.GetContainingNamespace();
if (!string.IsNullOrEmpty(ns.QualifiedName))
{
qualifiedName = ns.QualifiedName + "." + qualifiedName;
}
}
}
if (string.IsNullOrEmpty(qualifiedName))
{
qualifiedName = typeName.QualifiedName;
}
result.Template += qualifiedName + "(";
var index = 0;
foreach (var argument in creationExpression.Arguments)
{
var parameter = argument.MatchingParameter;
if (parameter == null)
{
continue;
}
var parameterName = parameter.Element.ShortName;
if (index > 0)
{
result.Template += ", ";
}
index++;
var argumentText = argument.GetText();
if (argumentText == variableName)
{
result.Template += "$VariableName$";
continue;
}
/*
if (argument.Value.IsConstantValue())
{
var constantValue = argument.Value.ConstantValue;
result.Template += "$" + parameterName + "$";
string s;
if (constantValue.IsPureNull(argument.Language))
{
s = "null";
}
else
{
s = constantValue.Value.ToString().Replace(",", ",").Replace(",", """);
if (constantValue.IsString())
{
s = "\"" + s + "\"";
}
}
result.TemplateVariables[parameterName] = "c:" + s;
continue;
}
*/
result.Template += "$" + parameterName + "$";
result.TemplateVariables[parameterName] = string.Empty;
}
result.Template += ")";
return result;
}
public static ExpressionDescriptor Handle(IExpression expression, Dictionary<string, string> scopeParameters)
{
var invocationExpression = expression as IInvocationExpression;
if (invocationExpression != null)
{
return new InvocationExpression().Handle(invocationExpression, scopeParameters);
}
var referenceExpression = expression as IReferenceExpression;
if (referenceExpression != null)
{
return new ReferenceExpression().Handle(referenceExpression, scopeParameters);
}
var binaryExpression = expression as IBinaryExpression;
if (binaryExpression != null)
{
return new BinaryExpression().Handle(binaryExpression, scopeParameters);
}
var isExpression = expression as IIsExpression;
if (isExpression != null)
{
return new IsExpression().Handle(isExpression, scopeParameters);
}
var asExpression = expression as IAsExpression;
if (asExpression != null)
{
return new AsExpression().Handle(asExpression, scopeParameters);
}
var castExpression = expression as ICastExpression;
if (castExpression != null)
{
return new CastExpression().Handle(castExpression, scopeParameters);
}
var unaryOperatorExpression = expression as IUnaryOperatorExpression;
if (unaryOperatorExpression != null)
{
return new UnaryOperatorExpression().Handle(unaryOperatorExpression, scopeParameters);
}
var parenthesizedExpression = expression as IParenthesizedExpression;
if (parenthesizedExpression != null)
{
return new ParenthesizedExpression().Handle(parenthesizedExpression, scopeParameters);
}
var thisExpression = expression as IThisExpression;
if (thisExpression != null)
{
return new ThisExpression().Handle(thisExpression, scopeParameters);
}
var creationExpression = expression as IObjectCreationExpression;
if (creationExpression != null)
{
return new CreationExpression().Handle(creationExpression, scopeParameters);
}
var result = new ExpressionDescriptor
{
Template = expression.GetText()
};
return result;
}
/// <summary>Handles the specified expression.</summary>
/// <param name="referenceExpression">The invoked expression.</param>
/// <param name="statementParameters">The parameters.</param>
/// <returns>Returns the string.</returns>
public ExpressionDescriptor Handle(IReferenceExpression referenceExpression, Dictionary<string, string> statementParameters)
{
var result = new ExpressionDescriptor();
var qualifierExpression = referenceExpression.QualifierExpression;
if (qualifierExpression != null)
{
var descriptor = ExpressionTemplateBuilder.Handle(qualifierExpression, statementParameters);
if (descriptor != null)
{
result.Template = descriptor.Template;
foreach (var variable in descriptor.TemplateVariables)
{
result.TemplateVariables[variable.Key] = variable.Value;
}
}
else
{
result.Template += qualifierExpression.GetText();
}
}
if (!string.IsNullOrEmpty(result.Template))
{
result.Template += ".";
}
var resolveResult = referenceExpression.Reference.Resolve();
var declaredElement = resolveResult.DeclaredElement;
string qualifiedName = null;
if (qualifierExpression == null && declaredElement != null)
{
var typeElement = declaredElement as ITypeElement;
if (typeElement != null)
{
qualifiedName = typeElement.ShortName;
var ns = typeElement.GetContainingNamespace();
if (!string.IsNullOrEmpty(ns.QualifiedName))
{
qualifiedName = ns.QualifiedName + "." + qualifiedName;
}
}
}
if (string.IsNullOrEmpty(qualifiedName))
{
qualifiedName = referenceExpression.NameIdentifier.GetText();
}
string variableName;
if (!statementParameters.TryGetValue("VariableName", out variableName))
{
variableName = string.Empty;
}
if (qualifiedName == variableName)
{
qualifiedName = "$VariableName$";
}
else
{
if (declaredElement != null)
{
var localVariable = declaredElement as ILocalVariable;
if (localVariable != null)
{
if (localVariable.Type.IsUnknown)
{
var name = declaredElement.ShortName;
qualifiedName = "$" + name + "$";
result.TemplateVariables[name] = "suggestVariableName()";
}
else
{
var name = localVariable.Type.GetPresentableName(declaredElement.PresentationLanguage).Replace("<", string.Empty).Replace(">", string.Empty).Replace(".", string.Empty);
qualifiedName = "$" + name + "$";
result.TemplateVariables[name] = string.Format("variableOfType(\"{0}\")", localVariable.Type.GetLongPresentableName(declaredElement.PresentationLanguage));
}
}
var parameter = declaredElement as IParameter;
if (parameter != null)
{
if (parameter.Type.IsUnknown)
{
var name = declaredElement.ShortName;
qualifiedName = "$" + name + "$";
result.TemplateVariables[name] = "suggestVariableName()";
}
else
{
var name = parameter.Type.GetPresentableName(declaredElement.PresentationLanguage).Replace("<", string.Empty).Replace(">", string.Empty).Replace(".", string.Empty);
qualifiedName = "$" + name + "$";
result.TemplateVariables[name] = string.Format("variableOfType(\"{0}\")", parameter.Type.GetLongPresentableName(declaredElement.PresentationLanguage));
}
}
}
}
result.Template += qualifiedName;
return result;
}
