public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
Debug.Assert((assignmentExpression != null));
Debug.Assert((assignmentExpression.Left != null));
Debug.Assert((assignmentExpression.Right != null));
assignmentExpression.Left.AcceptVisitor(this, data);
return assignmentExpression.Right.AcceptVisitor(this, data);
}
public override void VisitAssignmentExpression(AssignmentExpression expression)
{
base.VisitAssignmentExpression (expression);
Identifier identifier = expression.FindIdentifier();
if (identifier == null)
return;
switch (expression.Operator)
{
case AssignmentOperatorType.BitwiseOr:
case AssignmentOperatorType.BitwiseAnd:
case AssignmentOperatorType.ExclusiveOr:
case AssignmentOperatorType.Add:
case AssignmentOperatorType.Subtract:
case AssignmentOperatorType.Divide:
case AssignmentOperatorType.Modulus:
case AssignmentOperatorType.Multiply:
case AssignmentOperatorType.ShiftLeft:
case AssignmentOperatorType.ShiftRight:
case AssignmentOperatorType.Assign:
this.lineMap[this.id++] = expression.StartLocation.Line;
break;
}
}
public override void VisitAssignmentExpression(AssignmentExpression expression)
{
base.VisitAssignmentExpression (expression);
Identifier identifier = expression.FindIdentifier();
if (identifier == null)
return;
switch (expression.Operator)
{
case AssignmentOperatorType.BitwiseOr:
case AssignmentOperatorType.BitwiseAnd:
case AssignmentOperatorType.ExclusiveOr:
case AssignmentOperatorType.Add:
case AssignmentOperatorType.Subtract:
case AssignmentOperatorType.Divide:
case AssignmentOperatorType.Modulus:
case AssignmentOperatorType.Multiply:
case AssignmentOperatorType.ShiftLeft:
case AssignmentOperatorType.ShiftRight:
{
BinaryOperatorType op = GetComplexAssignOperator (expression.Operator);
Expression right = new BinaryOperatorExpression (new IdentifierExpression (identifier.Name), op, expression.Right.Clone());
expression.Operator = AssignmentOperatorType.Assign;
expression.Right = GetAssignmentExpression (identifier, right);
break;
}
case AssignmentOperatorType.Assign:
expression.Right = GetAssignmentExpression (identifier, expression.Right);
break;
}
}
public override IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
if (context.IsSomethingSelected) {
yield break;
}
AstType type;
var varInitializer = GetVariableDeclarationStatement(context, out type);
if (varInitializer == null)
yield break;
var statement = varInitializer.GetParent<Statement>();
var declaration = varInitializer.GetParent<VariableDeclarationStatement>();
if (declaration == null || (declaration.Modifiers & Modifiers.Const) != 0)
yield break;
var selectedNode = varInitializer.GetNodeAt(context.Location) ?? varInitializer;
yield return new CodeAction(context.TranslateString("Split local variable declaration and assignment"), script => {
var assign = new AssignmentExpression (new IdentifierExpression (varInitializer.Name), AssignmentOperatorType.Assign, varInitializer.Initializer.Clone());
if (declaration != null && declaration.Type.IsVar())
script.Replace(declaration.Type, type);
if (declaration.Parent is ForStatement) {
script.InsertBefore(statement, new VariableDeclarationStatement (type, varInitializer.Name));
script.Replace(declaration, assign);
} else {
script.Replace(varInitializer, new IdentifierExpression (varInitializer.Name));
script.InsertAfter(statement, new ExpressionStatement (assign));
}
}, selectedNode);
}
public override void Visit(AssignmentExpression expression)
{
outStream.Write(printFuncName + "(");
expression.Left.Accept(this);
switch (expression.AssignmentOperator)
{
case AssignmentOperator.Add: outStream.Write(" += "); break;
case AssignmentOperator.And: outStream.Write(" &= "); break;
case AssignmentOperator.Assign: outStream.Write(" = "); break;
case AssignmentOperator.Divide: outStream.Write(" /= "); break;
case AssignmentOperator.Modulo: outStream.Write(" %= "); break;
case AssignmentOperator.Multiply: outStream.Write(" *= "); break;
case AssignmentOperator.Or: outStream.Write(" |= "); break;
case AssignmentOperator.ShiftLeft: outStream.Write(" <<= "); break;
case AssignmentOperator.ShiftRight: outStream.Write(" >>= "); break;
case AssignmentOperator.Substract: outStream.Write(" -= "); break;
case AssignmentOperator.UnsignedRightShift: outStream.Write(" >>>= "); break;
case AssignmentOperator.XOr: outStream.Write(" ^= "); break;
}
expression.Right.Accept(this);
outStream.Write(", \"{0}\")", TempName);
//int currentTempCounter = tempCounter++;
//outStream.Write("{0}{1} = ", tempVarName, currentTempCounter);
//expression.Right.Accept(this);
//outStream.WriteLine(";");
//outStream.WriteLine("{0}{1};\nprint({0}{1});", tempVarName, currentTempCounter, tempVarName, currentTempCounter);
}
public override void VisitAssignmentExpression (AssignmentExpression assignmentExpression)
{
base.VisitAssignmentExpression (assignmentExpression);
if (assignmentExpression.Operator != AssignmentOperatorType.Assign)
return;
if (!(assignmentExpression.Left is IdentifierExpression) &&
!(assignmentExpression.Left is MemberReferenceExpression))
return;
var resolveResult = ctx.Resolve (assignmentExpression.Left);
var memberResolveResult = resolveResult as MemberResolveResult;
if (memberResolveResult != null) {
var memberResolveResult2 = ctx.Resolve (assignmentExpression.Right) as MemberResolveResult;
if (memberResolveResult2 == null || !AreEquivalent(memberResolveResult, memberResolveResult2))
return;
} else if (resolveResult is LocalResolveResult) {
if (!assignmentExpression.Left.Match (assignmentExpression.Right).Success)
return;
} else {
return;
}
AstNode node;
Action<Script> action;
if (assignmentExpression.Parent is ExpressionStatement) {
node = assignmentExpression.Parent;
action = script => script.Remove (assignmentExpression.Parent);
} else {
node = assignmentExpression;
action = script => script.Replace (assignmentExpression, assignmentExpression.Left.Clone ());
}
AddIssue (node, ctx.TranslateString ("CS1717:Assignment made to same variable"),
new [] { new CodeAction (ctx.TranslateString ("Remove assignment"), action) });
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
if (context.IsSomethingSelected) {
yield break;
}
AstType type;
var varDecl = GetVariableDeclarationStatement(context, out type);
if (varDecl == null) {
yield break;
}
yield return new CodeAction(context.TranslateString("Split local variable declaration and assignment"), script => {
var assign = new AssignmentExpression (new IdentifierExpression (varDecl.Variables.First().Name), AssignmentOperatorType.Assign, varDecl.Variables.First().Initializer.Clone());
var newVarDecl = (VariableDeclarationStatement)varDecl.Clone();
newVarDecl.Role = BlockStatement.StatementRole;
if (newVarDecl.Type.IsMatch(new SimpleType ("var"))) {
newVarDecl.Type = type;
}
newVarDecl.Variables.First().Initializer = Expression.Null;
script.InsertBefore(varDecl, newVarDecl);
script.Replace(varDecl, varDecl.Parent is ForStatement ? (AstNode)assign : new ExpressionStatement (assign));
}, varDecl.Variables.First ().AssignToken);
}
private static string GetNewEqualityTestCode(AssignmentExpression assignmentExpression)
{
RelationalOperation relationalOperation = new RelationalOperation(assignmentExpression.LeftSide.Clone() as Expression,
RelationalOperator.Equality,
assignmentExpression.RightSide.Clone() as Expression);
string newEqualityTest = CodeRush.Language.GenerateElement(relationalOperation);
return newEqualityTest;
}
public ArgumentsInfo(IEmitter emitter, AssignmentExpression assignmentExpression, OperatorResolveResult operatorResolveResult, IMethod method)
{
this.Emitter = emitter;
this.Expression = assignmentExpression;
this.OperatorResolveResult = operatorResolveResult;
this.BuildOperatorArgumentsList(new Expression[] { assignmentExpression.Left, assignmentExpression.Right }, operatorResolveResult.UserDefinedOperatorMethod ?? method);
this.BuildOperatorTypedArguments();
}
public override void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
// assignment is right-associative
ParenthesizeIfRequired(assignmentExpression.Left, Assignment + 1);
if (InsertParenthesesForReadability) {
ParenthesizeIfRequired(assignmentExpression.Right, RelationalAndTypeTesting + 1);
} else {
ParenthesizeIfRequired(assignmentExpression.Right, Assignment);
}
base.VisitAssignmentExpression(assignmentExpression);
}
public override Expression VisitAssignmentExpression(AssignmentExpression assign) {
AssignmentStatement stat = assign.AssignmentStatement as AssignmentStatement;
if (stat != null) {
stat.Target = this.VisitExpression(stat.Target);
stat.Source = this.VisitExpression(stat.Source);
}
this.composers.Clear();
if (stat != null) {
this.composers.Add(this.GetComposer(stat.Target));
this.composers.Add(this.GetComposer(stat.Source));
}
return (Expression) this.Compose(assign, this.composers);
}
public override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
{
var ns = assignmentExpression.GetCurrentNamespace();
var variable = assignmentExpression.Left.GetIdentifier();
var fullVariableName = ns + "." + variable;
if(_codebaseDeclarations.Any(a => a.FullName == fullVariableName && a.DeclarationClassType == TypeDeclarationKind.Event) && assignmentExpression.Operator == AssignmentOperatorType.Add)
{
UnlockWith(assignmentExpression);
}
return base.VisitAssignmentExpression(assignmentExpression, data);
}
public void EqualityInAssignment()
{
Expression expr = new AssignmentExpression(
new IdentifierExpression("cond"),
new BinaryOperatorExpression(
new IdentifierExpression("a"),
BinaryOperatorType.Equality,
new IdentifierExpression("b")
)
);
Assert.AreEqual("cond = a == b", InsertRequired(expr));
Assert.AreEqual("cond = (a == b)", InsertReadable(expr));
}
public override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
{
if (assignmentExpression.Right is PrimitiveExpression)
{
PrimitiveExpression prim = (PrimitiveExpression)assignmentExpression.Right;
int number;
if (int.TryParse(prim.LiteralValue, out number))
{
if (number == 666)
UnlockWith(assignmentExpression);
}
}
return base.VisitAssignmentExpression(assignmentExpression, data);
}
public AssignmentExpression ConvertToInitializer(AssignmentExpression assignmentExpression, ref IList<AstNode> statements)
{
if (assignmentExpression == null)
throw new ArgumentNullException("assignmentExpression");
if (statements == null)
throw new ArgumentNullException("statements");
if (!(assignmentExpression.Right is ObjectCreateExpression))
throw new ArgumentException("assignmentExpression.Right must be an ObjectCreateExpression", "assignmentExpression");
Initialize(assignmentExpression.Left);
accessPaths [mainAccessPath] = assignmentExpression.Right.Clone();
Convert(statements);
statements = ReplacementNodeHelper.GetReplacedNodes(accessPaths [mainAccessPath]);
return new AssignmentExpression(new IdentifierExpression(mainAccessPath.RootName), accessPaths [mainAccessPath]);
}
public IEnumerable<CodeAction> GetActions(RefactoringContext context)
{
//TODO: implement variable assignment & ctor param
var varInit = context.GetNode<VariableInitializer>();
if (varInit != null) {
AstType type = varInit.GetPrevNode() as AstType;
if (type == null) yield break;
if (varInit.Parent is FieldDeclaration) yield break;
if (CannotExtractField(varInit)) yield break;
yield return new CodeAction("Extract field", s=>{
var name = varInit.Name;
FieldDeclaration field = new FieldDeclaration(){
ReturnType = type.Clone(),
Variables = { new VariableInitializer(name) }
};
AstNode nodeToRemove = RemoveDeclaration(varInit) ? varInit.Parent : type;
s.Remove(nodeToRemove, true);
s.InsertWithCursor(context.TranslateString("Extract field"),Script.InsertPosition.Before,field);
s.FormatText(varInit.Parent);
});
}
var idntf = context.GetNode<Identifier>();
if (idntf == null) yield break;
var paramDec = idntf.Parent as ParameterDeclaration;
if (paramDec != null) {
var ctor = paramDec.Parent as ConstructorDeclaration;
if (ctor == null) yield break;
MemberReferenceExpression thisField = new MemberReferenceExpression(new ThisReferenceExpression(), idntf.Name, new AstType[]{});
var assign = new AssignmentExpression(thisField, AssignmentOperatorType.Assign, new IdentifierExpression(idntf.Name));
var statement = new ExpressionStatement(assign);
var type = (idntf.GetPrevNode() as AstType).Clone();
FieldDeclaration field = new FieldDeclaration(){
ReturnType = type.Clone(),
Variables = { new VariableInitializer(idntf.Name) }
};
yield return new CodeAction("Extract field", s=>{
s.InsertWithCursor(context.TranslateString("Extract field"),Script.InsertPosition.Before,field);
s.AddTo(ctor.Body, statement);
});
}
}
public void Run (RefactoringContext context)
{
AstType type;
var varDecl = GetVariableDeclarationStatement (context, out type);
var assign = new AssignmentExpression (new IdentifierExpression (varDecl.Variables.First ().Name), AssignmentOperatorType.Assign, varDecl.Variables.First ().Initializer.Clone ());
var newVarDecl = (VariableDeclarationStatement)varDecl.Clone ();
if (newVarDecl.Type.IsMatch (new SimpleType ("var")))
newVarDecl.Type = type;
newVarDecl.Variables.First ().Initializer = Expression.Null;
using (var script = context.StartScript ()) {
script.InsertBefore (varDecl, newVarDecl);
script.Replace (varDecl, varDecl.Parent is ForStatement ? (AstNode)assign : new ExpressionStatement (assign));
}
}
ResolveResult ResolveAssignment (RefactoringOptions options, AssignmentExpression assignment)
{
var resolver = options.GetResolver ();
var data = options.GetTextEditorData ();
string expression;
if (assignment.Left is IdentifierExpression) {
expression = ((IdentifierExpression)assignment.Left).Identifier;
} else {
var left = assignment.Left;
expression = data.GetTextBetween (left.StartLocation.Line, left.StartLocation.Column, left.EndLocation.Line, left.EndLocation.Column);
}
return resolver.Resolve (new ExpressionResult (expression), resolvePosition);
}
public virtual void Visit(AssignmentExpression expression)
{
logVisit(expression);
}
public override object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
{
if (this.FoundResourceSet == null && // skip if already found to improve performance
assignmentExpression.Op == AssignmentOperatorType.Assign && this.PositionAvailable &&
(!this.isLocalVariable || this.resourceManagerMember.Region.IsInside(this.CurrentNodeStartLocation.Y, this.CurrentNodeStartLocation.X)) // skip if local variable is out of scope
)
{
IMember resolvedMember = null;
ResolveResult rr = this.Resolve(assignmentExpression.Left);
if (rr != null)
{
// Support both local variables and member variables
MemberResolveResult mrr = rr as MemberResolveResult;
if (mrr != null)
{
resolvedMember = mrr.ResolvedMember;
}
else
{
LocalResolveResult lrr = rr as LocalResolveResult;
if (lrr != null)
{
resolvedMember = lrr.Field;
}
}
}
if (resolvedMember != null)
{
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: Resolved member: " + resolvedMember.ToString());
#endif
// HACK: The GetType()s are necessary because the DOM IComparable implementations try to cast the parameter object to their own interface type which may fail.
if (resolvedMember.GetType().Equals(this.resourceManagerMember.GetType()) && resolvedMember.CompareTo(this.resourceManagerMember) == 0)
{
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found assignment to field: " + assignmentExpression.ToString());
#endif
data = true;
// Resolving the property association only makes sense if
// there is a possible relationship between the return types
// of the resolved member and the member we are looking for.
}
else if (this.compilationUnit != null && !this.isLocalVariable &&
IsTypeRelationshipPossible(resolvedMember, this.resourceManagerMember))
{
if (this.resourceManagerMember is IProperty && resolvedMember is IField)
{
// Find out if the resourceManagerMember is a property whose get block returns the value of the resolved member.
// We might already have found this association in the
// resourceManagerFieldAccessedByProperty field.
this.TryResolveResourceManagerProperty();
if (this.resourceManagerFieldAccessedByProperty != null && this.resourceManagerFieldAccessedByProperty.CompareTo(resolvedMember) == 0)
{
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found assignment to field: " + assignmentExpression.ToString());
#endif
data = true;
}
}
else if (this.resourceManagerMember is IField && resolvedMember is IProperty)
{
// Find out if the resolved member is a property whose set block assigns the value to the resourceManagerMember.
PropertyFieldAssociationVisitor visitor = new PropertyFieldAssociationVisitor((IField)this.resourceManagerMember, this.FileName, this.FileContent);
this.compilationUnit.AcceptVisitor(visitor, null);
if (visitor.AssociatedProperty != null && visitor.AssociatedProperty.CompareTo(resolvedMember) == 0)
{
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found assignment to property: " + assignmentExpression.ToString());
#endif
data = true;
}
}
}
}
}
return(base.TrackedVisitAssignmentExpression(assignmentExpression, data));
}
/// <summary>
/// Returns the string representation of the underlying syntax, not including its leading and trailing trivia.
/// </summary>
/// <returns></returns>
public override string ToString()
{
return(AssignmentExpression?.ToString() ?? "");
}
public object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
{
throw new NotImplementedException();
}
public abstract T Visit(AssignmentExpression node);
public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
{
throw new global::System.NotImplementedException("AssignmentExpression");
}
/// <summary>
/// 式中のメンバアクセス、定数等を解析する。
/// </summary>
/// <param name="syntax"></param>
/// <param name="semanticModel"></param>
/// <returns></returns>
Expression ParseExpression(ExpressionSyntax syntax, SemanticModel semanticModel)
{
if (syntax == null)
{
return(null);
}
var mae = syntax as MemberAccessExpressionSyntax;
var gns = syntax as GenericNameSyntax;
var le = syntax as LiteralExpressionSyntax;
var ie = syntax as InvocationExpressionSyntax;
var oce = syntax as ObjectCreationExpressionSyntax;
var ce = syntax as CastExpressionSyntax;
var thise = syntax as ThisExpressionSyntax;
var ae = syntax as AssignmentExpressionSyntax;
var pe = syntax as ParenthesizedExpressionSyntax;
var ine = syntax as IdentifierNameSyntax;
var eae = syntax as ElementAccessExpressionSyntax;
var be = syntax as BinaryExpressionSyntax;
var preue = syntax as PrefixUnaryExpressionSyntax;
var poue = syntax as PostfixUnaryExpressionSyntax;
var basee = syntax as BaseExpressionSyntax;
var ace = syntax as ArrayCreationExpressionSyntax;
var sace = syntax as StackAllocArrayCreationExpressionSyntax;
var iee = syntax as InitializerExpressionSyntax;
/*
* var coe = syntax as ConditionalExpressionSyntax;
* var sle = syntax as SimpleLambdaExpressionSyntax;
* var ple = syntax as ParenthesizedLambdaExpressionSyntax;
* var oase = syntax as OmittedArraySizeExpressionSyntax;
* var iace = syntax as ImplicitArrayCreationExpressionSyntax;
*
* var qua = syntax as QualifiedNameSyntax;
* var predf = syntax as PredefinedTypeSyntax;
*/
// 自己の型を解析
TypeInfo?selfTypeInfo = null;
selfTypeInfo = semanticModel.GetTypeInfo(syntax);
var selfType = ParseType(syntax, selfTypeInfo, semanticModel);
if (mae != null)
{
MemberAccessExpression exp = new MemberAccessExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Name = mae.Name.ToString();
if (mae.Name is GenericNameSyntax)
{
var gns_ = mae.Name as GenericNameSyntax;
exp.Types = gns_.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray();
}
TypeInfo?parentType = null;
if (mae.Expression != null)
{
parentType = semanticModel.GetTypeInfo(mae.Expression);
}
// 種類を取得
var symbol = semanticModel.GetSymbolInfo(mae);
var methodSymbol = symbol.Symbol as IMethodSymbol;
var propertySymbol = symbol.Symbol as IPropertySymbol;
// 親の種類を探索
List <ClassDef> classDefPs = new List <ClassDef>();
EnumDef enumDefP = null;
InterfaceDef interfaceDefP = null;
StructDef structDefP = null;
// プロパティである
if (propertySymbol != null)
{
exp.IsProperty = true;
}
if (parentType.HasValue && parentType.Value.Type != null)
{
if (parentType.Value.Type.TypeKind == TypeKind.Interface)
{
var memName = mae.Name.ToString();
var sym = semanticModel.GetSymbolInfo(mae);
var name_ = parentType.Value.Type.Name;
var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace);
interfaceDefP = definitions.Interfaces.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault();
}
else if (parentType.Value.Type.TypeKind == TypeKind.Class)
{
var memName = mae.Name.ToString();
var sym = semanticModel.GetSymbolInfo(mae);
var name_ = parentType.Value.Type.Name;
var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace);
classDefPs = definitions.FindTypeWithBases(namespace_, name_).OfType <ClassDef>().ToList();
}
else if (parentType.Value.Type.TypeKind == TypeKind.Enum)
{
var enumName = selfTypeInfo.Value.Type.Name;
var namespace_ = Utils.ToStr(selfTypeInfo.Value.Type.ContainingNamespace);
enumDefP = definitions.Enums.Where(_ => _.Namespace == namespace_ && _.Name == enumName).FirstOrDefault();
}
else if (parentType.Value.Type.TypeKind == TypeKind.Struct)
{
var memName = mae.Name.ToString();
var sym = semanticModel.GetSymbolInfo(mae);
var name_ = parentType.Value.Type.Name;
var namespace_ = Utils.ToStr(parentType.Value.Type.ContainingNamespace);
structDefP = definitions.Structs.Where(_ => _.Namespace == namespace_ && _.Name == name_).FirstOrDefault();
}
}
// 親から子を探索
if (interfaceDefP != null)
{
if (methodSymbol != null)
{
var method = interfaceDefP.Methods.Where(_ =>
{
if (_.Name != methodSymbol.Name)
{
return(false);
}
if (_.Parameters.Count() != methodSymbol.Parameters.Count())
{
return(false);
}
for (int i = 0; i < _.Parameters.Count(); i++)
{
if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name)
{
return(false);
}
// TODO 正しい変換
//if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type)
}
return(true);
}).FirstOrDefault();
if (method != null)
{
exp.Name = null;
exp.Method = method;
}
}
else if (propertySymbol != null)
{
var prop = interfaceDefP.Properties.Where(_ =>
{
if (_.Name != propertySymbol.Name)
{
return(false);
}
return(true);
}).FirstOrDefault();
if (prop != null)
{
exp.Name = null;
exp.Property = prop;
}
}
}
else if (classDefPs.Count > 0)
{
if (methodSymbol != null)
{
foreach (var classDefP in classDefPs)
{
var method = classDefP.Methods.Where(_ =>
{
if (_.Name != methodSymbol.Name)
{
return(false);
}
if (_.Parameters.Count() != methodSymbol.Parameters.Count())
{
return(false);
}
for (int i = 0; i < _.Parameters.Count(); i++)
{
if (_.Parameters[i].Name != methodSymbol.Parameters[i].Name)
{
return(false);
}
// TODO 正しい変換
//if(_.Parameters[i].Type != methodSymbol.Parameters[i].Type)
}
return(true);
}).FirstOrDefault();
if (method != null)
{
exp.Name = null;
exp.Class = classDefP;
exp.Method = method;
// staticの場合走査停止
if (method.IsStatic)
{
return(exp);
}
break;
}
}
}
else if (propertySymbol != null)
{
foreach (var classDefP in classDefPs)
{
var prop = classDefP.Properties.Where(_ =>
{
if (_.Name != propertySymbol.Name)
{
return(false);
}
return(true);
}).FirstOrDefault();
if (prop != null)
{
exp.Name = null;
exp.Class = classDefP;
exp.Property = prop;
break;
}
}
}
}
else if (structDefP != null)
{
if (propertySymbol != null)
{
var prop = structDefP.Properties.Where(_ =>
{
if (_.Name != propertySymbol.Name)
{
return(false);
}
return(true);
}).FirstOrDefault();
if (prop != null)
{
exp.Name = null;
exp.Struct = structDefP;
exp.Property = prop;
}
}
}
else if (enumDefP != null)
{
var name = mae.Name.ToString();
exp.EnumMember = enumDefP.Members.Where(_ => _.Name == name).FirstOrDefault();
if (exp.EnumMember != null)
{
exp.Enum = enumDefP;
exp.Name = null;
}
}
else
{
// 代替処理
if (propertySymbol != null)
{
exp.Property = new PropertyDef();
exp.Property.Name = exp.Name;
}
}
if (exp.EnumMember != null)
{
// enumのメンバーだった場合、親は必ずenumなのでこれ以上走査しない
}
else if (mae.Expression != null)
{
exp.Expression = ParseExpression(mae.Expression, semanticModel);
}
return(exp);
}
else if (gns != null)
{
var symbol = semanticModel.GetSymbolInfo(gns);
var methodSymbol = symbol.Symbol as IMethodSymbol;
var fieldSymbol = symbol.Symbol as IFieldSymbol;
var propertySymbol = symbol.Symbol as IPropertySymbol;
var exp = new GenericNameExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Name = gns.Identifier.ValueText;
if (methodSymbol != null)
{
exp.IsMethod = true;
}
if (propertySymbol != null)
{
exp.IsProperty = true;
}
exp.Types = gns.TypeArgumentList.Arguments.Select(_ => ParseType(_, semanticModel)).ToArray();
return(exp);
}
else if (le != null)
{
var text = le.GetText().ToString();
var exp = new LiteralExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Text = text;
return(exp);
}
else if (ie != null)
{
var exp = new InvocationExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Method = ParseExpression(ie.Expression, semanticModel);
exp.Args = ie.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray();
return(exp);
}
else if (oce != null)
{
var exp = new ObjectCreationExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Type = ParseType(oce.Type, semanticModel);
if (oce.ArgumentList != null)
{
exp.Args = oce.ArgumentList.Arguments.Select(_ => ParseExpression(_.Expression, semanticModel)).ToArray();
}
else
{
exp.Args = new Expression[0];
}
return(exp);
}
else if (ce != null)
{
var exp = new CastExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Type = ParseType(ce.Type, semanticModel);
exp.Expression = ParseExpression(ce.Expression, semanticModel);
return(exp);
}
else if (thise != null)
{
var exp = new ThisExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
return(exp);
}
else if (ae != null)
{
var exp = new AssignmentExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
if (ae.Kind() == SyntaxKind.AddAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Add;
}
if (ae.Kind() == SyntaxKind.SubtractAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Substract;
}
if (ae.Kind() == SyntaxKind.SimpleAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Simple;
}
if (ae.Kind() == SyntaxKind.DivideAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Divide;
}
if (ae.Kind() == SyntaxKind.ModuloAssignmentExpression)
{
exp.Type = AssignmentExpression.OperatorType.Modulo;
}
exp.Temp = ae.Kind();
exp.Target = ParseExpression(ae.Left, semanticModel);
exp.Expression = ParseExpression(ae.Right, semanticModel);
return(exp);
}
else if (pe != null)
{
// ()の構文
return(ParseExpression(pe.Expression, semanticModel));
}
else if (ine != null)
{
var symbol = semanticModel.GetSymbolInfo(ine);
var methodSymbol = symbol.Symbol as IMethodSymbol;
var fieldSymbol = symbol.Symbol as IFieldSymbol;
var propertySymbol = symbol.Symbol as IPropertySymbol;
var exp = new IdentifierNameExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Name = ine.Identifier.Text;
if (selfTypeInfo?.Type != null)
{
exp.Type = ParseType(selfTypeInfo.Value.Type);
}
if (methodSymbol != null)
{
exp.IsMethod = true;
}
if (propertySymbol != null)
{
exp.IsProperty = true;
}
return(exp);
}
else if (eae != null)
{
if (eae.ArgumentList.Arguments.Count() != 1)
{
throw new ParseException("多次元配列は使用禁止です。");
}
var value_ = eae.Expression;
var arg = eae.ArgumentList.Arguments[0].Expression;
var exp = new ElementAccessExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Value = ParseExpression(value_, semanticModel);
exp.Arg = ParseExpression(arg, semanticModel);
return(exp);
}
else if (be != null)
{
var exp = new BinaryExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Left = ParseExpression(be.Left, semanticModel);
exp.Right = ParseExpression(be.Right, semanticModel);
if (be.Kind() == SyntaxKind.AddExpression)
{
exp.Operator = BinaryExpression.OperatorType.Add;
}
if (be.Kind() == SyntaxKind.SubtractExpression)
{
exp.Operator = BinaryExpression.OperatorType.Subtract;
}
if (be.Kind() == SyntaxKind.IsExpression)
{
exp.Operator = BinaryExpression.OperatorType.Is;
}
if (be.Kind() == SyntaxKind.AsExpression)
{
exp.Operator = BinaryExpression.OperatorType.As;
}
if (be.Kind() == SyntaxKind.EqualsExpression)
{
exp.Operator = BinaryExpression.OperatorType.Equals;
}
if (be.Kind() == SyntaxKind.NotEqualsExpression)
{
exp.Operator = BinaryExpression.OperatorType.NotEquals;
}
if (be.Kind() == SyntaxKind.LogicalAndExpression)
{
exp.Operator = BinaryExpression.OperatorType.LogicalAnd;
}
if (be.Kind() == SyntaxKind.LogicalOrExpression)
{
exp.Operator = BinaryExpression.OperatorType.LogicalOr;
}
if (be.Kind() == SyntaxKind.GreaterThanExpression)
{
exp.Operator = BinaryExpression.OperatorType.GreaterThan;
}
if (be.Kind() == SyntaxKind.GreaterThanOrEqualExpression)
{
exp.Operator = BinaryExpression.OperatorType.GreaterThanOrEqual;
}
if (be.Kind() == SyntaxKind.LessThanExpression)
{
exp.Operator = BinaryExpression.OperatorType.LessThan;
}
if (be.Kind() == SyntaxKind.LessThanOrEqualExpression)
{
exp.Operator = BinaryExpression.OperatorType.LessThanOrEqual;
}
if (be.Kind() == SyntaxKind.MultiplyExpression)
{
exp.Operator = BinaryExpression.OperatorType.Multiply;
}
if (be.Kind() == SyntaxKind.DivideExpression)
{
exp.Operator = BinaryExpression.OperatorType.Divide;
}
if (be.Kind() == SyntaxKind.ModuloExpression)
{
exp.Operator = BinaryExpression.OperatorType.Modulo;
}
if (exp.Operator == BinaryExpression.OperatorType.None)
{
var span_ = syntax.SyntaxTree.GetLineSpan(syntax.Span);
Console.WriteLine(string.Format("{0} : {1} には未対応です。", span_, be.Kind()));
}
return(exp);
}
else if (preue != null)
{
var exp = new PrefixUnaryExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Expression = ParseExpression(preue.Operand, semanticModel);
switch (preue.Kind())
{
case SyntaxKind.LogicalNotExpression:
exp.Type = PrefixUnaryExpression.OperatorType.LogicalNot;
break;
case SyntaxKind.UnaryPlusExpression:
exp.Type = PrefixUnaryExpression.OperatorType.UnaryPlus;
break;
case SyntaxKind.UnaryMinusExpression:
exp.Type = PrefixUnaryExpression.OperatorType.UnaryMinus;
break;
case SyntaxKind.PreIncrementExpression:
exp.Type = PrefixUnaryExpression.OperatorType.PreIncrement;
break;
default:
throw new Exception();
break;
}
return(exp);
}
else if (poue != null)
{
var exp = new PostfixUnaryExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Operand = ParseExpression(poue.Operand, semanticModel);
if (poue.Kind() == SyntaxKind.PostIncrementExpression)
{
exp.Type = PostfixUnaryExpression.OperatorType.PostIncrement;
}
if (poue.Kind() == SyntaxKind.PostDecrementExpression)
{
exp.Type = PostfixUnaryExpression.OperatorType.PostDecrement;
}
return(exp);
}
else if (basee != null)
{
var exp = new BaseExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
return(exp);
}
else if (iee != null)
{
var exp = new InitializerExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
var expressions = iee.Expressions.Select(_ => _).ToArray();
exp.Expressions = expressions.Select(_ => ParseExpression(_, semanticModel)).ToArray();
return(exp);
}
else if (ace != null || sace != null)
{
// stackallocも含め、配列の確保として扱う。
ArrayTypeSyntax ats = null;
if (ace != null)
{
ats = ace.Type;
}
if (sace != null)
{
ats = sace.Type as ArrayTypeSyntax;
}
var exp = new ObjectArrayCreationExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
exp.Type = ParseType(ats.ElementType, semanticModel);
exp.Args = ats.RankSpecifiers.Select(_ => ParseExpression(_.Sizes.FirstOrDefault(), semanticModel)).ToArray();
return(exp);
}
else if (syntax is PredefinedTypeSyntax)
{
var s = syntax as PredefinedTypeSyntax;
var exp = new TypeExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
return(exp);
}
else if (syntax is QualifiedNameSyntax)
{
var s = syntax as QualifiedNameSyntax;
var exp = new TypeExpression();
exp.SelfType = selfType;
exp.Internal = syntax;
return(exp);
}
var span = syntax.SyntaxTree.GetLineSpan(syntax.Span);
Console.WriteLine(string.Format("{0} : {1} には未対応です。", span, syntax.GetType()));
return(null);
}
protected abstract T CompileAssignmentExpression(AssignmentExpression expression);
public static Expression ConvertExpression(RenderState render, Method method, Expression s, VHDLType target, Mono.Cecil.TypeReference targetsource, bool fromCast)
{
var svhdl = render.VHDLType(s);
// Deal with pesky integers that overflow the 32bit VHDL specs
if (IsTooLargeIntegerLiteral(s, target))
{
svhdl = render.TypeScope.StdLogicVectorEquivalent(target);
}
// Already the real target type, just return it
if (svhdl == target)
{
return(s);
}
// Stuff we do not care about
if (!svhdl.IsStdLogicVector && !svhdl.IsUnsigned && !svhdl.IsSigned && svhdl.IsArray && target.IsArray && render.TypeScope.GetByName(svhdl.ElementName) == render.TypeScope.GetByName(target.ElementName))
{
return(s);
}
// Array lengths
var targetlengthstr = string.IsNullOrWhiteSpace(target.Alias) ? target.Length.ToString() : target.Alias + "'length";
if (target == VHDLTypes.SYSTEM_BOOL)
{
// Boolean to std_logic is fine
if (string.Equals("STD_LOGIC", svhdl.Name, StringComparison.OrdinalIgnoreCase))
{
return(s);
}
// Source is numeric, and output is bool
if (svhdl.IsNumeric || svhdl.IsStdLogicVector)
{
var zero = new PrimitiveExpression()
{
SourceExpression = s.SourceExpression,
SourceResultType = s.SourceResultType,
Value = 0
};
var eval = new BinaryOperatorExpression()
{
Parent = s.Parent,
Name = s.Name,
SourceExpression = s.SourceExpression,
SourceResultType = s.SourceResultType.LoadType(typeof(bool)),
Left = s,
Operator = ICSharpCode.Decompiler.CSharp.Syntax.BinaryOperatorType.InEquality,
Right = zero
};
zero.Parent = eval;
s.ReplaceWith(eval);
s.Parent = eval;
return(eval);
}
else if (svhdl == VHDLTypes.BOOL)
{
var truexp = new PrimitiveExpression()
{
Value = true,
SourceExpression = s.SourceExpression,
SourceResultType = s.SourceResultType.LoadType(typeof(bool)),
};
var falseexp = new PrimitiveExpression()
{
Value = false,
SourceExpression = s.SourceExpression,
SourceResultType = s.SourceResultType.LoadType(typeof(bool)),
};
var eval = new ConditionalExpression()
{
ConditionExpression = s,
TrueExpression = truexp,
FalseExpression = falseexp,
SourceExpression = s.SourceExpression,
SourceResultType = truexp.SourceResultType
};
truexp.Parent = eval;
falseexp.Parent = eval;
s.ReplaceWith(eval);
s.Parent = eval;
return(eval);
}
else
{
throw new Exception(string.Format("Unexpected conversion from {0} to {1}", svhdl, target));
}
}
else if (svhdl == VHDLTypes.INTEGER && (target.IsStdLogicVector || target.IsNumeric))
{
if (target.IsSigned && target.IsNumeric)
{
return(WrapExpression(render, s, string.Format("TO_SIGNED({0}, {1})", "{0}", targetlengthstr), target));
}
else if (target.IsUnsigned && target.IsNumeric)
{
return(WrapExpression(render, s, string.Format("TO_UNSIGNED({0}, {1})", "{0}", targetlengthstr), target));
}
else if (target.IsStdLogicVector)
{
return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(TO_UNSIGNED({0}, {1}))", "{0}", targetlengthstr), target));
}
else
{
throw new Exception(string.Format("Unexpected conversion from {0} to {1}", svhdl, target));
}
}
else if (target.IsNumeric && !svhdl.IsEnum)
{
if (svhdl.IsStdLogicVector || svhdl.IsSigned || svhdl.IsUnsigned)
{
var str = "{0}";
var resized = false;
Variable tmpvar = null;
if (target.Length != svhdl.Length)
{
if (svhdl.IsVHDLSigned)
{
// Resizing with signed is bad because we may chop the upper bit
resized = true;
str = string.Format("SIGNED(resize(UNSIGNED({0}), {1}))", str, targetlengthstr);
}
else if (svhdl.IsVHDLUnsigned)
{
resized = true;
str = string.Format("resize({0}, {1})", str, targetlengthstr);
}
else if (svhdl.IsSystemSigned)
{
// Resizing with signed is bad because we may chop the upper bit
str = string.Format("SIGNED(resize(UNSIGNED({0}), {1}))", str, targetlengthstr);
svhdl = render.TypeScope.NumericEquivalent(svhdl);
resized = true;
}
else if (svhdl.IsSystemUnsigned)
{
str = string.Format("resize(UNSIGNED({0}), {1})", str, targetlengthstr);
svhdl = render.TypeScope.NumericEquivalent(svhdl);
resized = true;
}
else if (target.Length > svhdl.Length)
{
// This must be a variable as bit concatenation is only allowed in assignment statements:
// http://stackoverflow.com/questions/209458/concatenating-bits-in-vhdl
tmpvar = render.RegisterTemporaryVariable(method, targetsource);
render.TypeLookup[tmpvar] = target;
var iexp = new IdentifierExpression()
{
Name = tmpvar.Name,
Target = tmpvar,
SourceExpression = s.SourceExpression,
SourceResultType = targetsource
};
string wstr;
if (render.Config.USE_EXPLICIT_CONCATENATION_OPERATOR)
{
wstr = string.Format("IEEE.STD_LOGIC_1164.\"&\"(\"{0}\", {1})", new string('0', target.Length - svhdl.Length), "{0}");
}
else
{
wstr = string.Format("\"{0}\" & {1}", new string('0', target.Length - svhdl.Length), "{0}");
}
s.ReplaceWith(iexp);
var asstm = new ExpressionStatement()
{
Expression = new AssignmentExpression()
{
Left = iexp.Clone(),
Right = new CustomNodes.ConversionExpression()
{
Expression = s,
SourceExpression = s.SourceExpression,
SourceResultType = targetsource,
WrappingTemplate = wstr,
},
Operator = ICSharpCode.Decompiler.CSharp.Syntax.AssignmentOperatorType.Assign,
SourceExpression = s.SourceExpression,
SourceResultType = targetsource
},
};
s.PrependStatement(asstm);
asstm.UpdateParents();
resized = true;
s = iexp;
}
}
if (svhdl.IsVHDLSigned != target.IsSigned || svhdl.IsVHDLUnsigned != target.IsUnsigned)
{
str = string.Format("{1}({0})", str, target.IsSigned ? "SIGNED" : "UNSIGNED");
}
if (target.Length != svhdl.Length && !resized)
{
str = string.Format("resize({0}, {1})", str, targetlengthstr);
}
return(WrapExpression(render, s, str, target));
}
/*if (svhdl.IsStdLogicVector && target.IsSigned)
* return new VHDLConvertedExpression(s, target, "SIGNED({0})");
* else if (svhdl.IsStdLogicVector && target.IsUnsigned)
* return new VHDLConvertedExpression(s, target, "UNSIGNED({0})");
* else*/
throw new Exception(string.Format("Unexpected conversion from {0} to {1}", svhdl, target));
}
else if (target.IsStdLogicVector)
{
if (svhdl.IsNumeric)
{
if (svhdl.Length == target.Length)
{
return(WrapExpression(render, s, "STD_LOGIC_VECTOR({0})", target));
}
else
{
if (!fromCast)
{
Console.WriteLine("WARN: Incompatible array lengths, from {0} to {1}", svhdl, target);
}
//throw new Exception(string.Format("Incompatible array lengths, from {0} to {1}", svhdl, target));
if (target.Length < svhdl.Length && svhdl.IsNumericSigned)
{
return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize(UNSIGNED({0}), {1}))", "{0}", targetlengthstr), target));
}
else
{
return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize({0}, {1}))", "{0}", targetlengthstr), target));
}
}
}
else if (svhdl.IsStdLogicVector)
{
if (target.Length == svhdl.Length)
{
render.TypeLookup[s] = target;
return(s);
}
if (!fromCast)
{
Console.WriteLine("WARN: Incompatible array lengths, from {0} to {1}", svhdl, target);
}
//throw new Exception(string.Format("Incompatible array lengths, from {0} to {1}", svhdl, target));
if (target.Length < svhdl.Length)
{
// If the expression is a simple identifier, we can select bits from it
// otherwise we need to inject a variable with the expression
// and select the required bits from it
if (!(s is IdentifierExpression || s is MemberReferenceExpression || s is IndexerExpression))
{
var tmp = render.RegisterTemporaryVariable(method, s.SourceResultType);
render.TypeLookup[tmp] = svhdl;
var aleft = new IdentifierExpression()
{
Name = tmp.Name,
Target = tmp,
SourceExpression = s.SourceExpression,
SourceResultType = s.SourceResultType
};
var aexp = new AssignmentExpression()
{
Left = aleft,
Right = s,
SourceExpression = s.SourceExpression,
SourceResultType = s.SourceResultType
};
var astm = new ExpressionStatement()
{
Expression = aexp,
Parent = method,
};
var iexp = new IdentifierExpression()
{
SourceExpression = s.SourceExpression,
SourceResultType = s.SourceResultType,
Target = tmp
};
s.ReplaceWith(iexp);
s.PrependStatement(astm);
astm.UpdateParents();
return(WrapExpression(render, iexp, string.Format("{0}({1} downto 0)", "{0}", target.Length - 1), target));
}
return(WrapExpression(render, s, string.Format("{0}({1} downto 0)", "{0}", target.Length - 1), target));
}
else if (svhdl.IsSigned)
{
return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize(SIGNED({0}), {1}))", "{0}", targetlengthstr), target));
}
else if (svhdl.IsUnsigned)
{
return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize(UNSIGNED({0}), {1}))", "{0}", targetlengthstr), target));
}
else
{
var tmp = render.RegisterTemporaryVariable(method, targetsource);
render.TypeLookup[tmp] = target;
var iexp = new IdentifierExpression()
{
Name = tmp.Name,
Target = tmp,
SourceExpression = s.SourceExpression,
SourceResultType = targetsource
};
render.TypeLookup[iexp] = target;
string wexpr;
if (render.Config.USE_EXPLICIT_CONCATENATION_OPERATOR)
{
wexpr = string.Format("IEEE.STD_LOGIC_1164.\"&\"(\"{0}\", {1})", new string('0', target.Length - svhdl.Length), "{0}");
}
else
{
wexpr = string.Format("\"{0}\" & {1}", new string('0', target.Length - svhdl.Length), "{0}");
}
s.ReplaceWith(iexp);
var asstm = new ExpressionStatement();
s.PrependStatement(asstm);
var asexp = new AssignmentExpression()
{
Left = iexp.Clone(),
Operator = ICSharpCode.Decompiler.CSharp.Syntax.AssignmentOperatorType.Assign,
Right = new CustomNodes.ConversionExpression()
{
Expression = s,
SourceExpression = s.SourceExpression,
SourceResultType = targetsource,
WrappingTemplate = wexpr
},
SourceExpression = s.SourceExpression,
SourceResultType = targetsource
};
render.TypeLookup[asexp.Left] = target;
render.TypeLookup[asexp.Right] = target;
asexp.Left.SourceResultType = targetsource;
asexp.Right.SourceResultType = targetsource;
asstm.Expression = asexp;
asstm.UpdateParents();
return(iexp);
}
}
else if (svhdl.IsSigned || svhdl.IsUnsigned)
{
if (target.Length == svhdl.Length)
{
return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR({0})", "{0}"), target));
}
else
{
return(WrapExpression(render, s, string.Format("STD_LOGIC_VECTOR(resize({0}, {1}))", "{0}", targetlengthstr), target));
}
}
else
{
throw new Exception(string.Format("Unexpected conversion from {0} to {1}", svhdl.Name, target.Name));
}
}
else if (target == VHDLTypes.INTEGER && (svhdl.IsStdLogicVector || svhdl.IsNumeric))
{
if (svhdl.IsNumeric)
{
return(WrapExpression(render, s, "TO_INTEGER({0})", target));
}
if (svhdl.IsSigned)
{
return(WrapExpression(render, s, "TO_INTEGER(SIGNED({0}))", target));
}
else
{
return(WrapExpression(render, s, "TO_INTEGER(UNSIGNED({0}))", target));
}
}
else if (target == VHDLTypes.INTEGER && (svhdl.IsSystemSigned || svhdl.IsSystemUnsigned))
{
return(WrapExpression(render, s, "TO_INTEGER({0})", target));
}
else if (target == VHDLTypes.BOOL && svhdl == VHDLTypes.SYSTEM_BOOL)
{
return(WrapInParenthesis(render, WrapExpression(render, s, "{0} = '1'", target)));
}
else if ((target.IsSigned || target.IsUnsigned) && svhdl.IsStdLogicVector)
{
if (target.Length == svhdl.Length)
{
return(WrapExpression(render, s, string.Format("{1}({0})", "{0}", target.IsSigned ? "SIGNED" : "UNSIGNED"), target));
}
else
{
return(WrapExpression(render, s, string.Format("resize({1}({0}), {2})", "{0}", target.IsSigned ? "SIGNED" : "UNSIGNED", targetlengthstr), target));
}
}
else if ((target.IsSigned || target.IsUnsigned) && svhdl == VHDLTypes.INTEGER)
{
if (target.IsSigned)
{
return(WrapExpression(render, s, string.Format("TO_SIGNED({0}, {1})", "{0}", target.Length), target));
}
else if (target.IsUnsigned)
{
return(WrapExpression(render, s, string.Format("TO_UNSIGNED({0}, {1})", "{0}", target.Length), target));
}
else
{
throw new Exception("Unexpected case");
}
}
else if ((svhdl.IsSigned || svhdl.IsUnsigned) && (target.IsSigned || target.IsUnsigned))
{
if (target.Length == svhdl.Length)
{
if (svhdl.IsSigned == target.IsSigned)
{
return(s);
}
else
{
return(WrapExpression(render, s, string.Format("{1}({0})", "{0}", target.IsSigned ? "SIGNED" : "UNSIGNED"), target));
}
}
else
{
if (svhdl.IsSigned == target.IsSigned)
{
return(WrapExpression(render, s, string.Format("resize({0}, {1})", "{0}", targetlengthstr), target));
}
else if (svhdl.IsSigned && svhdl.Length > target.Length)
{
return(WrapExpression(render, s, string.Format("resize(UNSIGNED({0}), {1})", "{0}", targetlengthstr), target));
}
else
{
return(WrapExpression(render, s, string.Format("{2}(resize({0}, {1}))", "{0}", targetlengthstr, target.IsSigned ? "SIGNED" : "UNSIGNED"), target));
}
}
}
else if (target.IsEnum && (svhdl.IsSigned || svhdl.IsUnsigned || svhdl == VHDLTypes.INTEGER))
{
if (target.IsIrregularEnum)
{
return(WrapExpression(render, s, string.Format("fromValue_{1}({0})", svhdl == VHDLTypes.INTEGER ? "{0}" : "TO_INTEGER({0})", target.ToSafeVHDLName()), target));
}
else
{
return(WrapExpression(render, s, string.Format("{1}'VAL({0})", svhdl == VHDLTypes.INTEGER ? "{0}" : "TO_INTEGER({0})", target.ToSafeVHDLName()), target));
}
}
else if (svhdl.IsEnum && (target.IsSigned || target.IsUnsigned || target == VHDLTypes.INTEGER))
{
Expression wrapped;
if (target.IsIrregularEnum)
{
wrapped = WrapExpression(render, s, string.Format("toValue_{1}({0})", "{0}", svhdl.ToSafeVHDLName()), target);
}
else
{
wrapped = WrapExpression(render, s, string.Format("{1}'POS({0})", "{0}", svhdl.ToSafeVHDLName()), target);
}
render.TypeLookup[wrapped] = VHDLTypes.INTEGER;
if (target != VHDLTypes.INTEGER)
{
wrapped = ConvertExpression(render, method, wrapped, target, targetsource, false);
}
return(wrapped);
}
else
{
throw new Exception(string.Format("Unexpected target type: {0} for source: {1}", target, svhdl));
}
}
protected void VisitAssignmentExpression()
{
AssignmentExpression assignmentExpression = this.AssignmentExpression;
var oldAssigment = this.Emitter.IsAssignment;
var oldAssigmentType = this.Emitter.AssignmentType;
string variable = null;
bool needReturnValue = !(assignmentExpression.Parent is ExpressionStatement);
if (needReturnValue && assignmentExpression.Parent is LambdaExpression)
{
var lambdarr = this.Emitter.Resolver.ResolveNode(assignmentExpression.Parent, this.Emitter) as LambdaResolveResult;
if (lambdarr != null && lambdarr.ReturnType.Kind == TypeKind.Void)
{
needReturnValue = false;
}
}
var delegateAssigment = false;
bool isEvent = false;
var initCount = this.Emitter.Writers.Count;
var asyncExpressionHandling = this.Emitter.AsyncExpressionHandling;
this.WriteAwaiters(assignmentExpression.Left);
this.WriteAwaiters(assignmentExpression.Right);
var leftResolverResult = this.Emitter.Resolver.ResolveNode(assignmentExpression.Left, this.Emitter);
var rightResolverResult = this.Emitter.Resolver.ResolveNode(assignmentExpression.Right, this.Emitter);
var rr = this.Emitter.Resolver.ResolveNode(assignmentExpression, this.Emitter);
var orr = rr as OperatorResolveResult;
bool isDecimal = Helpers.IsDecimalType(rr.Type, this.Emitter.Resolver);
bool isLong = Helpers.Is64Type(rr.Type, this.Emitter.Resolver);
var expectedType = this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression);
bool isDecimalExpected = Helpers.IsDecimalType(expectedType, this.Emitter.Resolver);
bool isLongExpected = Helpers.Is64Type(expectedType, this.Emitter.Resolver);
bool isUserOperator = this.IsUserOperator(orr);
bool isUint = rr.Type.IsKnownType(KnownTypeCode.UInt16) ||
rr.Type.IsKnownType(KnownTypeCode.UInt32) ||
rr.Type.IsKnownType(KnownTypeCode.UInt64);
var charToString = -1;
if (orr != null && orr.Type.IsKnownType(KnownTypeCode.String))
{
for (int i = 0; i < orr.Operands.Count; i++)
{
var crr = orr.Operands[i] as ConversionResolveResult;
if (crr != null && crr.Input.Type.IsKnownType(KnownTypeCode.Char))
{
charToString = i;
}
}
}
var memberTargetrr = leftResolverResult as MemberResolveResult;
bool isField = (memberTargetrr != null && memberTargetrr.Member is IField &&
(memberTargetrr.TargetResult is ThisResolveResult ||
memberTargetrr.TargetResult is LocalResolveResult)) || leftResolverResult is ThisResolveResult || leftResolverResult is LocalResolveResult || leftResolverResult is ConstantResolveResult;
var rightMemberTargetrr = rightResolverResult as MemberResolveResult;
bool isRightSimple = (rightMemberTargetrr != null && rightMemberTargetrr.Member is IField &&
(rightMemberTargetrr.TargetResult is ThisResolveResult ||
rightMemberTargetrr.TargetResult is LocalResolveResult)) || rightResolverResult is ThisResolveResult || rightResolverResult is LocalResolveResult || rightResolverResult is ConstantResolveResult;
var needTempVar = needReturnValue && (!isRightSimple && !isField || assignmentExpression.Operator != AssignmentOperatorType.Assign);
/*if (assignmentExpression.Operator == AssignmentOperatorType.Any)
* {
* needTempVar = false;
* }*/
if (needReturnValue)
{
if (needTempVar)
{
variable = this.GetTempVarName();
this.Write("(" + variable + " = ");
var oldValue1 = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
assignmentExpression.Right.AcceptVisitor(this.Emitter);
this.Emitter.ReplaceAwaiterByVar = oldValue1;
this.Write(", ");
}
else
{
this.Write("(");
}
}
if (assignmentExpression.Operator == AssignmentOperatorType.Divide && this.Emitter.Rules.Integer == IntegerRule.Managed &&
!(this.Emitter.IsJavaScriptOverflowMode && !ConversionBlock.InsideOverflowContext(this.Emitter, assignmentExpression)) &&
!isLong && !isLongExpected &&
(
(Helpers.IsIntegerType(leftResolverResult.Type, this.Emitter.Resolver) &&
Helpers.IsIntegerType(rightResolverResult.Type, this.Emitter.Resolver)) ||
(Helpers.IsIntegerType(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Left), this.Emitter.Resolver) &&
Helpers.IsIntegerType(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Right), this.Emitter.Resolver))
))
{
this.Emitter.IsAssignment = true;
this.Emitter.AssignmentType = AssignmentOperatorType.Assign;
var oldValue1 = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
this.AcceptLeftExpression(assignmentExpression.Left, memberTargetrr);
if (this.Emitter.Writers.Count == initCount)
{
this.Write(" = ");
}
this.Emitter.ReplaceAwaiterByVar = oldValue1;
this.Emitter.AssignmentType = oldAssigmentType;
this.Emitter.IsAssignment = oldAssigment;
this.Write(JS.Types.BRIDGE_INT + "." + JS.Funcs.Math.DIV + "(");
assignmentExpression.Left.AcceptVisitor(this.Emitter);
this.Write(", ");
oldValue1 = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
assignmentExpression.Right.AcceptVisitor(this.Emitter);
this.Write(")");
this.Emitter.ReplaceAwaiterByVar = oldValue1;
this.Emitter.AsyncExpressionHandling = asyncExpressionHandling;
if (this.Emitter.Writers.Count > initCount)
{
this.PopWriter();
}
if (needReturnValue && !isField)
{
if (needTempVar)
{
this.Write(", " + variable);
}
else
{
this.Write(", ");
this.Emitter.IsAssignment = false;
assignmentExpression.Right.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldAssigment;
}
}
if (needReturnValue)
{
this.Write(")");
}
return;
}
if (assignmentExpression.Operator == AssignmentOperatorType.Multiply && this.Emitter.Rules.Integer == IntegerRule.Managed &&
!(this.Emitter.IsJavaScriptOverflowMode && !ConversionBlock.InsideOverflowContext(this.Emitter, assignmentExpression)) &&
!isLong && !isLongExpected &&
(
(Helpers.IsInteger32Type(leftResolverResult.Type, this.Emitter.Resolver) &&
Helpers.IsInteger32Type(rightResolverResult.Type, this.Emitter.Resolver) &&
Helpers.IsInteger32Type(rr.Type, this.Emitter.Resolver)) ||
(Helpers.IsInteger32Type(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Left), this.Emitter.Resolver) &&
Helpers.IsInteger32Type(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Right), this.Emitter.Resolver) &&
Helpers.IsInteger32Type(rr.Type, this.Emitter.Resolver))
))
{
this.Emitter.IsAssignment = true;
this.Emitter.AssignmentType = AssignmentOperatorType.Assign;
var oldValue1 = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
this.AcceptLeftExpression(assignmentExpression.Left, memberTargetrr);
if (this.Emitter.Writers.Count == initCount)
{
this.Write(" = ");
}
this.Emitter.ReplaceAwaiterByVar = oldValue1;
this.Emitter.AssignmentType = oldAssigmentType;
this.Emitter.IsAssignment = oldAssigment;
isUint = NullableType.GetUnderlyingType(rr.Type).IsKnownType(KnownTypeCode.UInt32);
this.Write(JS.Types.BRIDGE_INT + "." + (isUint ? JS.Funcs.Math.UMUL : JS.Funcs.Math.MUL) + "(");
assignmentExpression.Left.AcceptVisitor(this.Emitter);
this.Write(", ");
oldValue1 = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
assignmentExpression.Right.AcceptVisitor(this.Emitter);
if (ConversionBlock.IsInCheckedContext(this.Emitter, assignmentExpression))
{
this.Write(", 1");
}
this.Write(")");
this.Emitter.ReplaceAwaiterByVar = oldValue1;
this.Emitter.AsyncExpressionHandling = asyncExpressionHandling;
if (this.Emitter.Writers.Count > initCount)
{
this.PopWriter();
}
if (needReturnValue && !isField)
{
if (needTempVar)
{
this.Write(", " + variable);
}
else
{
this.Write(", ");
this.Emitter.IsAssignment = false;
assignmentExpression.Right.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldAssigment;
}
}
if (needReturnValue)
{
this.Write(")");
}
return;
}
bool templateDelegateAssigment = false;
if (assignmentExpression.Operator == AssignmentOperatorType.Add ||
assignmentExpression.Operator == AssignmentOperatorType.Subtract)
{
var add = assignmentExpression.Operator == AssignmentOperatorType.Add;
if (this.Emitter.Validator.IsDelegateOrLambda(leftResolverResult))
{
delegateAssigment = true;
var leftMemberResolveResult = leftResolverResult as MemberResolveResult;
if (leftMemberResolveResult != null)
{
isEvent = leftMemberResolveResult.Member is IEvent;
this.Emitter.IsAssignment = true;
this.Emitter.AssignmentType = assignmentExpression.Operator;
templateDelegateAssigment = !string.IsNullOrWhiteSpace(this.Emitter.GetInline(leftMemberResolveResult.Member));
this.Emitter.IsAssignment = false;
}
if (!isEvent)
{
this.Emitter.IsAssignment = true;
this.Emitter.AssignmentType = AssignmentOperatorType.Assign;
this.AcceptLeftExpression(assignmentExpression.Left, memberTargetrr);
this.Emitter.IsAssignment = false;
if (this.Emitter.Writers.Count == initCount)
{
this.Write(" = ");
}
this.Write(add ? JS.Funcs.BRIDGE_COMBINE : JS.Funcs.BRIDGE_REMOVE);
this.WriteOpenParentheses();
}
}
}
bool nullable = orr != null && orr.IsLiftedOperator;
string root = JS.Types.SYSTEM_NULLABLE + ".";
bool special = nullable;
this.Emitter.IsAssignment = true;
this.Emitter.AssignmentType = assignmentExpression.Operator;
var oldValue = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
bool thisAssignment = leftResolverResult is ThisResolveResult;
if (!thisAssignment)
{
if (special || (isDecimal && isDecimalExpected) || (isLong && isLongExpected) || isUserOperator)
{
this.Emitter.AssignmentType = AssignmentOperatorType.Assign;
}
if (delegateAssigment && !isEvent)
{
this.Emitter.IsAssignment = false;
}
this.AcceptLeftExpression(assignmentExpression.Left, memberTargetrr);
if (delegateAssigment)
{
this.Emitter.IsAssignment = true;
}
}
else
{
this.Write("(");
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AssignmentType = oldAssigmentType;
this.Emitter.IsAssignment = oldAssigment;
if (this.Emitter.Writers.Count == initCount && !delegateAssigment && !thisAssignment)
{
this.WriteSpace();
}
if (isDecimal && isDecimalExpected)
{
if (this.Emitter.Writers.Count == initCount)
{
this.Write("= ");
}
oldValue = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
this.HandleDecimal(rr, variable);
if (this.Emitter.Writers.Count > initCount)
{
this.PopWriter();
}
if (needTempVar)
{
this.Write(", " + variable + ")");
}
else if (needReturnValue)
{
if (!isField)
{
this.Write(", ");
this.Emitter.IsAssignment = false;
assignmentExpression.Right.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldAssigment;
}
this.Write(")");
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
return;
}
if (isLong && isLongExpected)
{
if (this.Emitter.Writers.Count == initCount)
{
this.Write("= ");
}
oldValue = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
this.HandleLong(rr, variable, isUint);
if (this.Emitter.Writers.Count > initCount)
{
this.PopWriter();
}
if (needTempVar)
{
this.Write(", " + variable + ")");
}
else if (needReturnValue)
{
if (!isField)
{
this.Write(", ");
this.Emitter.IsAssignment = false;
assignmentExpression.Right.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldAssigment;
}
this.Write(")");
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
return;
}
if (this.ResolveOperator(assignmentExpression, orr, initCount, thisAssignment))
{
if (thisAssignment)
{
this.Write(")." + JS.Funcs.CLONE + "(this)");
}
else if (needReturnValue)
{
this.Write(")");
}
return;
}
bool isBool = NullableType.IsNullable(rr.Type) ? NullableType.GetUnderlyingType(rr.Type).IsKnownType(KnownTypeCode.Boolean) : rr.Type.IsKnownType(KnownTypeCode.Boolean);
if (!delegateAssigment)
{
if (!special)
{
switch (assignmentExpression.Operator)
{
case AssignmentOperatorType.Assign:
break;
case AssignmentOperatorType.Add:
this.Write("+");
break;
case AssignmentOperatorType.BitwiseAnd:
if (!isBool)
{
this.Write("&");
}
break;
case AssignmentOperatorType.BitwiseOr:
if (!isBool)
{
this.Write("|");
}
break;
case AssignmentOperatorType.Divide:
this.Write("/");
break;
case AssignmentOperatorType.ExclusiveOr:
this.Write("^");
break;
case AssignmentOperatorType.Modulus:
this.Write("%");
break;
case AssignmentOperatorType.Multiply:
this.Write("*");
break;
case AssignmentOperatorType.ShiftLeft:
this.Write("<<");
break;
case AssignmentOperatorType.ShiftRight:
this.Write(isUint ? ">>>" : ">>");
break;
case AssignmentOperatorType.Subtract:
this.Write("-");
break;
default:
throw new EmitterException(assignmentExpression,
"Unsupported assignment operator: " + assignmentExpression.Operator.ToString());
}
}
if (special)
{
if (this.Emitter.Writers.Count == initCount)
{
this.Write("= ");
}
this.Write(root);
switch (assignmentExpression.Operator)
{
case AssignmentOperatorType.Assign:
break;
case AssignmentOperatorType.Add:
this.Write(JS.Funcs.Math.ADD);
break;
case AssignmentOperatorType.BitwiseAnd:
this.Write(isBool ? JS.Funcs.Math.AND : JS.Funcs.Math.BAND);
break;
case AssignmentOperatorType.BitwiseOr:
this.Write(isBool ? JS.Funcs.Math.OR : JS.Funcs.Math.BOR);
break;
case AssignmentOperatorType.Divide:
this.Write(JS.Funcs.Math.DIV);
break;
case AssignmentOperatorType.ExclusiveOr:
this.Write(JS.Funcs.Math.XOR);
break;
case AssignmentOperatorType.Modulus:
this.Write(JS.Funcs.Math.MOD);
break;
case AssignmentOperatorType.Multiply:
this.Write(JS.Funcs.Math.MUL);
break;
case AssignmentOperatorType.ShiftLeft:
this.Write(JS.Funcs.Math.SL);
break;
case AssignmentOperatorType.ShiftRight:
this.Write(isUint ? JS.Funcs.Math.SRR : JS.Funcs.Math.SR);
break;
case AssignmentOperatorType.Subtract:
this.Write(JS.Funcs.Math.SUB);
break;
default:
throw new EmitterException(assignmentExpression,
"Unsupported assignment operator: " + assignmentExpression.Operator.ToString());
}
this.WriteOpenParentheses();
assignmentExpression.Left.AcceptVisitor(this.Emitter);
this.Write(", ");
}
if (this.Emitter.Writers.Count == initCount && !thisAssignment && !special)
{
this.Write("= ");
}
}
else if (!isEvent)
{
this.WriteComma();
}
if (!special && isBool && (assignmentExpression.Operator == AssignmentOperatorType.BitwiseAnd || assignmentExpression.Operator == AssignmentOperatorType.BitwiseOr))
{
this.Write("!!(");
assignmentExpression.Left.AcceptVisitor(this.Emitter);
this.Write(assignmentExpression.Operator == AssignmentOperatorType.BitwiseAnd ? " & " : " | ");
}
oldValue = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
if (charToString == 1)
{
this.Write(JS.Funcs.STRING_FROMCHARCODE + "(");
}
if (needTempVar)
{
int pos = this.Emitter.Output.Length;
this.Write(variable);
Helpers.CheckValueTypeClone(rr, assignmentExpression.Right, this, pos);
}
else
{
var wrap = assignmentExpression.Operator != AssignmentOperatorType.Assign &&
this.Emitter.Writers.Count > initCount &&
!AssigmentExpressionHelper.CheckIsRightAssigmentExpression(assignmentExpression);
if (wrap)
{
this.WriteOpenParentheses();
}
assignmentExpression.Right.AcceptVisitor(this.Emitter);
if (wrap)
{
this.WriteCloseParentheses();
}
}
if (!special && isBool &&
(assignmentExpression.Operator == AssignmentOperatorType.BitwiseAnd ||
assignmentExpression.Operator == AssignmentOperatorType.BitwiseOr))
{
this.WriteCloseParentheses();
}
if (charToString == 1)
{
this.WriteCloseParentheses();
}
if (special)
{
this.WriteCloseParentheses();
}
if (thisAssignment)
{
this.Write(")." + JS.Funcs.CLONE + "(this)");
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = asyncExpressionHandling;
if (this.Emitter.Writers.Count > initCount)
{
var writerCount = this.Emitter.Writers.Count;
for (int i = initCount; i < writerCount; i++)
{
this.PopWriter();
}
}
if (delegateAssigment && !templateDelegateAssigment)
{
this.WriteCloseParentheses();
}
if (needTempVar)
{
this.Write(", " + variable + ")");
}
else if (needReturnValue)
{
if (!isField)
{
this.Write(", ");
this.Emitter.IsAssignment = false;
assignmentExpression.Right.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = oldAssigment;
}
this.Write(")");
}
}
protected override void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
VisitingAssignmentExpression?.Invoke(this, assignmentExpression);
base.VisitAssignmentExpression(assignmentExpression);
VisitedAssignmentExpression?.Invoke(this, assignmentExpression);
}
private bool IsMatch(AssignmentExpression uoe, AssignmentExpression r_uoe)
{
return(uoe.Op == r_uoe.Op);
}
void ConvertForStatement(ForStatement forStatement)
{
// ForStatement -> ForNextStatement when for-loop is simple
// only the following forms of the for-statement are allowed:
// for (TypeReference name = start; name < oneAfterEnd; name += step)
// for (name = start; name < oneAfterEnd; name += step)
// for (TypeReference name = start; name <= end; name += step)
// for (name = start; name <= end; name += step)
// for (TypeReference name = start; name > oneAfterEnd; name -= step)
// for (name = start; name > oneAfterEnd; name -= step)
// for (TypeReference name = start; name >= end; name -= step)
// for (name = start; name >= end; name -= step)
// check if the form is valid and collect TypeReference, name, start, end and step
if (forStatement.Initializers.Count != 1)
{
return;
}
if (forStatement.Iterator.Count != 1)
{
return;
}
ExpressionStatement statement = forStatement.Iterator[0] as ExpressionStatement;
if (statement == null)
{
return;
}
AssignmentExpression iterator = statement.Expression as AssignmentExpression;
if (iterator == null || (iterator.Op != AssignmentOperatorType.Add && iterator.Op != AssignmentOperatorType.Subtract))
{
return;
}
IdentifierExpression iteratorIdentifier = iterator.Left as IdentifierExpression;
if (iteratorIdentifier == null)
{
return;
}
PrimitiveExpression stepExpression = iterator.Right as PrimitiveExpression;
if (stepExpression == null || !(stepExpression.Value is int))
{
return;
}
int step = (int)stepExpression.Value;
if (iterator.Op == AssignmentOperatorType.Subtract)
{
step = -step;
}
BinaryOperatorExpression condition = forStatement.Condition as BinaryOperatorExpression;
if (condition == null || !(condition.Left is IdentifierExpression))
{
return;
}
if ((condition.Left as IdentifierExpression).Identifier != iteratorIdentifier.Identifier)
{
return;
}
Expression end;
if (iterator.Op == AssignmentOperatorType.Subtract)
{
if (condition.Op == BinaryOperatorType.GreaterThanOrEqual)
{
end = condition.Right;
}
else if (condition.Op == BinaryOperatorType.GreaterThan)
{
end = Expression.AddInteger(condition.Right, 1);
}
else
{
return;
}
}
else
{
if (condition.Op == BinaryOperatorType.LessThanOrEqual)
{
end = condition.Right;
}
else if (condition.Op == BinaryOperatorType.LessThan)
{
end = Expression.AddInteger(condition.Right, -1);
}
else
{
return;
}
}
Expression start;
TypeReference typeReference = null;
LocalVariableDeclaration varDecl = forStatement.Initializers[0] as LocalVariableDeclaration;
if (varDecl != null)
{
if (varDecl.Variables.Count != 1 ||
varDecl.Variables[0].Name != iteratorIdentifier.Identifier ||
varDecl.Variables[0].Initializer == null)
{
return;
}
typeReference = varDecl.GetTypeForVariable(0);
start = varDecl.Variables[0].Initializer;
}
else
{
statement = forStatement.Initializers[0] as ExpressionStatement;
if (statement == null)
{
return;
}
AssignmentExpression assign = statement.Expression as AssignmentExpression;
if (assign == null || assign.Op != AssignmentOperatorType.Assign)
{
return;
}
if (!(assign.Left is IdentifierExpression))
{
return;
}
if ((assign.Left as IdentifierExpression).Identifier != iteratorIdentifier.Identifier)
{
return;
}
start = assign.Right;
}
ReplaceCurrentNode(
new ForNextStatement
{
TypeReference = typeReference,
VariableName = iteratorIdentifier.Identifier,
Start = start,
End = end,
Step = (step == 1) ? null : new PrimitiveExpression(step, step.ToString(System.Globalization.NumberFormatInfo.InvariantInfo)),
EmbeddedStatement = forStatement.EmbeddedStatement
});
}
static bool CanMoveVariableUseIntoSubBlock(Statement stmt, string variableName, bool allowPassIntoLoops)
{
if (!allowPassIntoLoops && (stmt is ForStatement || stmt is ForeachStatement || stmt is DoWhileStatement || stmt is WhileStatement))
{
return(false);
}
ForStatement forStatement = stmt as ForStatement;
if (forStatement != null && forStatement.Initializers.Count == 1)
{
// for-statement is special case: we can move variable declarations into the initializer
ExpressionStatement es = forStatement.Initializers.Single() as ExpressionStatement;
if (es != null)
{
AssignmentExpression ae = es.Expression as AssignmentExpression;
if (ae != null && ae.Operator == AssignmentOperatorType.Assign)
{
IdentifierExpression ident = ae.Left as IdentifierExpression;
if (ident != null && ident.Identifier == variableName)
{
return(!UsesVariable(ae.Right, variableName));
}
}
}
}
UsingStatement usingStatement = stmt as UsingStatement;
if (usingStatement != null)
{
// using-statement is special case: we can move variable declarations into the initializer
AssignmentExpression ae = usingStatement.ResourceAcquisition as AssignmentExpression;
if (ae != null && ae.Operator == AssignmentOperatorType.Assign)
{
IdentifierExpression ident = ae.Left as IdentifierExpression;
if (ident != null && ident.Identifier == variableName)
{
return(!UsesVariable(ae.Right, variableName));
}
}
}
IfElseStatement ies = stmt as IfElseStatement;
if (ies != null)
{
foreach (var child in IfElseChainChildren(ies))
{
if (!(child is BlockStatement) && UsesVariable(child, variableName))
{
return(false);
}
}
return(true);
}
// We can move the variable into a sub-block only if the variable is used in only that sub-block (and not in expressions such as the loop condition)
for (AstNode child = stmt.FirstChild; child != null; child = child.NextSibling)
{
if (!(child is BlockStatement) && UsesVariable(child, variableName))
{
if (HasNestedBlocks(child))
{
// catch clauses/switch sections can contain nested blocks
for (AstNode grandchild = child.FirstChild; grandchild != null; grandchild = grandchild.NextSibling)
{
if (!(grandchild is BlockStatement) && UsesVariable(grandchild, variableName))
{
return(false);
}
}
}
else
{
return(false);
}
}
}
return(true);
}
public virtual S VisitAssignmentExpression(AssignmentExpression assignmentExpression, T data)
{
return(VisitChildren(assignmentExpression, data));
}
public virtual void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
VisitExpression(assignmentExpression.Left.As <Expression>());
VisitExpression(assignmentExpression.Right.As <Expression>());
}
public override void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
new AssignmentBlock(this, assignmentExpression).Emit();
}
protected virtual string VisitAssignment(AssignmentExpression exp, out object resultObj)
{
resultObj = null;
return(null);
}
public override void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
base.VisitAssignmentExpression(assignmentExpression);
Check(assignmentExpression.Left);
}
public virtual Expression VisitAssignmentExpression(AssignmentExpression assignment, AssignmentExpression changes, AssignmentExpression deletions, AssignmentExpression insertions){
this.UpdateSourceContext(assignment, changes);
if (assignment == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
assignment.AssignmentStatement = this.VisitAssignmentStatement(assignment.AssignmentStatement as AssignmentStatement, changes.AssignmentStatement as AssignmentStatement, deletions.AssignmentStatement as AssignmentStatement, insertions.AssignmentStatement as AssignmentStatement);
}
}else if (deletions != null)
return null;
return assignment;
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
//TODO: implement variable assignment & ctor param
var varInit = context.GetNode <VariableInitializer>();
if (varInit != null)
{
AstType type = varInit.GetPrevNode() as AstType;
if (type == null)
{
yield break;
}
if (varInit.Parent is FieldDeclaration)
{
yield break;
}
if (CannotExtractField(varInit))
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Assign to new field"), s => {
var name = varInit.Name;
FieldDeclaration field = new FieldDeclaration()
{
ReturnType = type.Clone(),
Variables = { new VariableInitializer(name) }
};
AstNode nodeToRemove = RemoveDeclaration(varInit) ? varInit.Parent : type;
s.Remove(nodeToRemove, true);
s.InsertWithCursor(context.TranslateString("Insert new field"), Script.InsertPosition.Before, field);
s.FormatText(varInit.Parent);
}));
}
var idntf = context.GetNode <Identifier>();
if (idntf == null)
{
yield break;
}
var paramDec = idntf.Parent as ParameterDeclaration;
if (paramDec != null)
{
var ctor = paramDec.Parent as ConstructorDeclaration;
if (ctor == null)
{
yield break;
}
MemberReferenceExpression thisField = new MemberReferenceExpression(new ThisReferenceExpression(), idntf.Name, new AstType[] {});
var assign = new AssignmentExpression(thisField, AssignmentOperatorType.Assign, new IdentifierExpression(idntf.Name));
var statement = new ExpressionStatement(assign);
var type = (idntf.GetPrevNode() as AstType).Clone();
FieldDeclaration field = new FieldDeclaration()
{
ReturnType = type.Clone(),
Variables = { new VariableInitializer(idntf.Name) }
};
yield return(new CodeAction(context.TranslateString("Assign to new field"), s => {
s.InsertWithCursor(context.TranslateString("Insert new field"), Script.InsertPosition.Before, field);
s.AddTo(ctor.Body, statement);
}));
}
}
public override object Visit (CompoundAssign compoundAssign)
{
var result = new AssignmentExpression ();
int opLength = 2;
switch (compoundAssign.Op) {
case Binary.Operator.Multiply:
result.AssignmentOperatorType = AssignmentOperatorType.Multiply;
break;
case Binary.Operator.Division:
result.AssignmentOperatorType = AssignmentOperatorType.Divide;
break;
case Binary.Operator.Modulus:
result.AssignmentOperatorType = AssignmentOperatorType.Modulus;
break;
case Binary.Operator.Addition:
result.AssignmentOperatorType = AssignmentOperatorType.Add;
break;
case Binary.Operator.Subtraction:
result.AssignmentOperatorType = AssignmentOperatorType.Subtract;
break;
case Binary.Operator.LeftShift:
result.AssignmentOperatorType = AssignmentOperatorType.ShiftLeft;
opLength = 3;
break;
case Binary.Operator.RightShift:
result.AssignmentOperatorType = AssignmentOperatorType.ShiftRight;
opLength = 3;
break;
case Binary.Operator.BitwiseAnd:
result.AssignmentOperatorType = AssignmentOperatorType.BitwiseAnd;
break;
case Binary.Operator.BitwiseOr:
result.AssignmentOperatorType = AssignmentOperatorType.BitwiseOr;
break;
case Binary.Operator.ExclusiveOr:
result.AssignmentOperatorType = AssignmentOperatorType.ExclusiveOr;
break;
}
result.AddChild ((INode)compoundAssign.Target.Accept (this), AssignmentExpression.LeftExpressionRole);
result.AddChild (new CSharpTokenNode (Convert (compoundAssign.Location), opLength), AssignmentExpression.OperatorRole);
result.AddChild ((INode)compoundAssign.Source.Accept (this), AssignmentExpression.RightExpressionRole);
return result;
}
public virtual void Visit(AssignmentExpression expression, TContext context)
{
VisitAssignmentLeftNode(expression.Left, context);
VisitExpression(expression.Right, context);
}
CodeAction CreateFromStatements(RefactoringContext context, List<AstNode> statements)
{
if (!(statements [0].Parent is Statement))
return null;
return new CodeAction(context.TranslateString("Extract method"), script => {
string methodName = "NewMethod";
var method = new MethodDeclaration() {
ReturnType = new PrimitiveType("void"),
Name = methodName,
Body = new BlockStatement()
};
bool usesNonStaticMember = false;
foreach (var node in statements) {
usesNonStaticMember |= StaticVisitor.UsesNotStaticMember(context, node);
if (node is Statement) {
method.Body.Add((Statement)node.Clone());
} else {
method.Body.AddChildUnsafe (node.Clone (), node.Role);
}
}
if (!usesNonStaticMember)
method.Modifiers |= Modifiers.Static;
var target = new IdentifierExpression(methodName);
var invocation = new InvocationExpression(target);
var usedVariables = VariableLookupVisitor.Analyze(context, statements);
var inExtractedRegion = new VariableUsageAnalyzation (context, usedVariables);
var lastStatement = statements [statements.Count - 1];
var stmt = statements [0].GetParent<BlockStatement>();
while (stmt.GetParent<BlockStatement> () != null) {
stmt = stmt.GetParent<BlockStatement>();
}
inExtractedRegion.SetAnalyzedRange(statements [0], lastStatement);
stmt.AcceptVisitor (inExtractedRegion);
var beforeExtractedRegion = new VariableUsageAnalyzation (context, usedVariables);
beforeExtractedRegion.SetAnalyzedRange(statements [0].Parent, statements [0], true, false);
stmt.AcceptVisitor (beforeExtractedRegion);
var afterExtractedRegion = new VariableUsageAnalyzation (context, usedVariables);
afterExtractedRegion.SetAnalyzedRange(lastStatement, stmt.Statements.Last(), false, true);
stmt.AcceptVisitor (afterExtractedRegion);
usedVariables.Sort ((l, r) => l.Region.Begin.CompareTo (r.Region.Begin));
IVariable generatedReturnVariable = null;
foreach (var variable in usedVariables) {
if ((variable is IParameter) || beforeExtractedRegion.Has (variable) || !afterExtractedRegion.Has (variable))
continue;
generatedReturnVariable = variable;
method.ReturnType = context.CreateShortType (variable.Type);
method.Body.Add (new ReturnStatement (new IdentifierExpression (variable.Name)));
break;
}
int parameterOutCount = 0;
foreach (var variable in usedVariables) {
if (!(variable is IParameter) && !beforeExtractedRegion.Has (variable) && !afterExtractedRegion.Has (variable))
continue;
if (variable == generatedReturnVariable)
continue;
Expression argumentExpression = new IdentifierExpression(variable.Name);
ParameterModifier mod = ParameterModifier.None;
if (inExtractedRegion.GetStatus (variable) == VariableState.Changed) {
if (beforeExtractedRegion.GetStatus (variable) == VariableState.None) {
mod = ParameterModifier.Out;
argumentExpression = new DirectionExpression(FieldDirection.Out, argumentExpression);
parameterOutCount++;
} else {
mod = ParameterModifier.Ref;
argumentExpression = new DirectionExpression(FieldDirection.Ref, argumentExpression);
}
}
method.Parameters.Add(new ParameterDeclaration(context.CreateShortType(variable.Type), variable.Name, mod));
invocation.Arguments.Add(argumentExpression);
}
ParameterDeclaration parameterToTransform = null;
bool transformParameterToReturn = method.ReturnType is PrimitiveType &&
((PrimitiveType)method.ReturnType).Keyword == "void" &&
parameterOutCount == 1;
if(transformParameterToReturn) {
parameterToTransform = method.Parameters.First(p => p.ParameterModifier == ParameterModifier.Out);
parameterToTransform.Remove();
var argumentExpression = invocation.Arguments.OfType<DirectionExpression>().First(a => a.FieldDirection == FieldDirection.Out);
argumentExpression.Remove();
method.ReturnType = parameterToTransform.Type.Clone();
var argumentDecl = new VariableDeclarationStatement(parameterToTransform.Type.Clone(),parameterToTransform.Name);
method.Body.InsertChildBefore(method.Body.First(),argumentDecl,BlockStatement.StatementRole);
method.Body.Add(new ReturnStatement (new IdentifierExpression (parameterToTransform.Name)));
}
script
.InsertWithCursor(context.TranslateString("Extract method"), Script.InsertPosition.Before, method)
.ContinueScript(delegate {
foreach (var node in statements.Skip (1)) {
if (node is NewLineNode)
continue;
script.Remove(node);
}
foreach (var variable in usedVariables) {
if ((variable is IParameter) || beforeExtractedRegion.Has (variable) || !afterExtractedRegion.Has (variable))
continue;
if (variable == generatedReturnVariable)
continue;
script.InsertBefore (statements [0], new VariableDeclarationStatement (context.CreateShortType(variable.Type), variable.Name));
}
Statement invocationStatement;
if (generatedReturnVariable != null) {
invocationStatement = new VariableDeclarationStatement (new SimpleType ("var"), generatedReturnVariable.Name, invocation);
} else if(transformParameterToReturn) {
invocationStatement = new AssignmentExpression(new IdentifierExpression(parameterToTransform.Name), invocation);
} else {
invocationStatement = invocation;
}
script.Replace(statements [0], invocationStatement);
script.Link(target, method.NameToken);
});
}, statements.First ().StartLocation, statements.Last ().EndLocation);
}
public virtual void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
if (this.ThrowException)
{
throw (Exception)this.CreateException(assignmentExpression);
}
}
/// <inheritdoc />
public override void Visit(AssignmentExpression assignmentExpression)
{
VisitDynamic(assignmentExpression.Target);
WriteSpace().Write(assignmentExpression.Operator.ConvertToString()).WriteSpace();
VisitDynamic(assignmentExpression.Value);
}
public override StringBuilder VisitAssignmentExpression(AssignmentExpression assignmentExpression, int data)
{
var result = assignmentExpression.Left.AcceptVisitor(this, data);
switch (assignmentExpression.Operator)
{
case AssignmentOperatorType.Assign:
result.Append(" = ");
break;
case AssignmentOperatorType.Add:
result.Append(" += ");
break;
case AssignmentOperatorType.BitwiseAnd:
result.Append(" &= ");
break;
case AssignmentOperatorType.BitwiseOr:
result.Append(" |= ");
break;
case AssignmentOperatorType.Divide:
result.Append(" /= ");
break;
case AssignmentOperatorType.ExclusiveOr:
result.Append(" ^= ");
break;
case AssignmentOperatorType.Modulus:
result.Append(" %= ");
break;
case AssignmentOperatorType.Multiply:
result.Append(" *= ");
break;
case AssignmentOperatorType.ShiftLeft:
result.Append(" <<= ");
break;
case AssignmentOperatorType.ShiftRight:
result.Append(" >>= ");
break;
case AssignmentOperatorType.Subtract:
result.Append(" -= ");
break;
default:
throw new NotImplementedException();
}
result.Append(assignmentExpression.Right.AcceptVisitor(this, data));
return result;
}
protected bool ResolveOperator(AssignmentExpression assignmentExpression, OperatorResolveResult orr, int initCount)
{
var method = orr != null ? orr.UserDefinedOperatorMethod : null;
if (method != null)
{
var inline = this.Emitter.GetInline(method);
if (!string.IsNullOrWhiteSpace(inline))
{
if (this.Emitter.Writers.Count == initCount)
{
this.Write("= ");
}
new InlineArgumentsBlock(this.Emitter,
new ArgumentsInfo(this.Emitter, assignmentExpression, orr, method), inline).Emit();
if (this.Emitter.Writers.Count > initCount)
{
this.PopWriter();
}
return(true);
}
else if (!this.Emitter.Validator.IsIgnoreType(method.DeclaringTypeDefinition))
{
if (this.Emitter.Writers.Count == initCount)
{
this.Write("= ");
}
if (orr.IsLiftedOperator)
{
this.Write(Bridge.Translator.Emitter.ROOT + ".Nullable.lift(");
}
this.Write(BridgeTypes.ToJsName(method.DeclaringType, this.Emitter));
this.WriteDot();
this.Write(OverloadsCollection.Create(this.Emitter, method).GetOverloadName());
if (orr.IsLiftedOperator)
{
this.WriteComma();
}
else
{
this.WriteOpenParentheses();
}
new ExpressionListBlock(this.Emitter,
new Expression[] { assignmentExpression.Left, assignmentExpression.Right }, null).Emit();
this.WriteCloseParentheses();
if (this.Emitter.Writers.Count > initCount)
{
this.PopWriter();
}
return(true);
}
}
return(false);
}
public void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
throw new NotImplementedException();
}
/// <summary>
/// Applies the transformation
/// </summary>
/// <returns>The transformed item.</returns>
/// <param name="el">The item to visit.</param>
public ASTItem Transform(ASTItem el)
{
var uoe = el as UnaryOperatorExpression;
if (uoe == null)
{
return(el);
}
var incr =
new[] {
ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.Increment,
ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.Decrement,
ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostIncrement,
ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostDecrement
}.Contains(uoe.Operator);
if (!incr)
{
return(el);
}
var cnst = new PrimitiveExpression()
{
SourceExpression = uoe.SourceExpression,
SourceResultType = uoe.SourceResultType.LoadType(typeof(int)),
Value = 1
};
State.TypeLookup[cnst] = VHDLTypes.INTEGER;
var boe = new BinaryOperatorExpression()
{
Left = uoe.Operand.Clone(),
Right = cnst,
SourceExpression = uoe.SourceExpression,
SourceResultType = uoe.SourceResultType,
Operator =
uoe.Operator == ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.Decrement
||
uoe.Operator == ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostDecrement
? ICSharpCode.Decompiler.CSharp.Syntax.BinaryOperatorType.Subtract
: ICSharpCode.Decompiler.CSharp.Syntax.BinaryOperatorType.Add
};
State.TypeLookup[boe] = State.VHDLType(uoe.Operand);
// Prepare an assignment expresion
var ase = new AssignmentExpression()
{
Left = uoe.Operand.Clone(),
Right = boe,
Operator = ICSharpCode.Decompiler.CSharp.Syntax.AssignmentOperatorType.Assign,
SourceExpression = uoe.SourceExpression,
SourceResultType = uoe.SourceResultType
};
var exps = new ExpressionStatement()
{
Expression = ase,
};
exps.UpdateParents();
if (uoe.Operator == ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostIncrement || uoe.Operator == ICSharpCode.Decompiler.CSharp.Syntax.UnaryOperatorType.PostDecrement)
{
if (uoe.Parent is ExpressionStatement || uoe.Parent is ForStatement)
{
// Simple "i++;" statements are replaced with i = i + 1
uoe.ReplaceWith(ase);
return(ase);
}
else
{
// More complicated are split
uoe.AppendStatement(exps);
// Remove the operator now, as the assignment happens after
uoe.ReplaceWith(uoe.Operand);
return(exps);
}
}
else
{
// If the left-hand-side is also the target, we can just replace
// with the binary operator without needing a temporary variable
if (uoe.Operand.GetTarget() != null && boe.Parent is AssignmentExpression && ((AssignmentExpression)boe.Parent).Left.GetTarget() == uoe.Operand.GetTarget())
{
uoe.ReplaceWith(boe);
return(boe);
}
else
{
// TODO: Can have more complex cases where
// the expression is use multiple times in the same statement and some need the updated version,
// others the non-updated version.
// To support this, we need to seek for references to the target
// and replace the references with the correct pre/post versions
uoe.PrependStatement(exps);
uoe.ReplaceWith(boe);
return(boe);
}
}
}
public override object Visit(CompoundAssign compoundAssign)
{
var result = new AssignmentExpression();
switch (compoundAssign.Op) {
case Binary.Operator.Multiply:
result.Operator = AssignmentOperatorType.Multiply;
break;
case Binary.Operator.Division:
result.Operator = AssignmentOperatorType.Divide;
break;
case Binary.Operator.Modulus:
result.Operator = AssignmentOperatorType.Modulus;
break;
case Binary.Operator.Addition:
result.Operator = AssignmentOperatorType.Add;
break;
case Binary.Operator.Subtraction:
result.Operator = AssignmentOperatorType.Subtract;
break;
case Binary.Operator.LeftShift:
result.Operator = AssignmentOperatorType.ShiftLeft;
break;
case Binary.Operator.RightShift:
result.Operator = AssignmentOperatorType.ShiftRight;
break;
case Binary.Operator.BitwiseAnd:
result.Operator = AssignmentOperatorType.BitwiseAnd;
break;
case Binary.Operator.BitwiseOr:
result.Operator = AssignmentOperatorType.BitwiseOr;
break;
case Binary.Operator.ExclusiveOr:
result.Operator = AssignmentOperatorType.ExclusiveOr;
break;
}
if (compoundAssign.Target != null)
result.AddChild((Expression)compoundAssign.Target.Accept(this), AssignmentExpression.LeftRole);
var location = LocationsBag.GetLocations(compoundAssign);
if (location != null) {
var r = AssignmentExpression.GetOperatorRole(result.Operator);
result.AddChild(new CSharpTokenNode(Convert(location [0]), r), r);
}
if (compoundAssign.Source != null)
result.AddChild((Expression)compoundAssign.Source.Accept(this), AssignmentExpression.RightRole);
return result;
}
public void VisitAssignment(AssignmentExpression assignment)
{
assignment.Left.AcceptWalker(this);
assignment.Right.AcceptWalker(this);
}
public override object Visit(SimpleAssign simpleAssign)
{
var result = new AssignmentExpression();
result.Operator = AssignmentOperatorType.Assign;
if (simpleAssign.Target != null)
result.AddChild((Expression)simpleAssign.Target.Accept(this), AssignmentExpression.LeftRole);
var location = LocationsBag.GetLocations(simpleAssign);
if (location != null)
result.AddChild(new CSharpTokenNode(Convert(location [0]), AssignmentExpression.AssignRole), AssignmentExpression.AssignRole);
if (simpleAssign.Source != null) {
result.AddChild((Expression)simpleAssign.Source.Accept(this), AssignmentExpression.RightRole);
}
return result;
}
protected override void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
// left side skipped (imports are read-only)
Visit(assignmentExpression.Right);
}
public virtual void VisitAssignmentExpression (AssignmentExpression assignmentExpression)
{
VisitChildren (assignmentExpression);
}
protected override CodeAction GetAction(RefactoringContext context, IfElseStatement node)
{
var match = ActionPattern.Match(node.Condition);
if (!match.Success)
{
return(null);
}
var conditionExpression = match.Get <BinaryOperatorExpression>(expressionGroupName).Single();
bool isEqualityComparison = conditionExpression.Operator == BinaryOperatorType.Equality;
Expression comparedNode = match.Get <Expression>(comparedNodeGroupName).Single();
Statement contentStatement;
if (isEqualityComparison)
{
contentStatement = node.TrueStatement;
if (!IsEmpty(node.FalseStatement))
{
return(null);
}
}
else
{
contentStatement = node.FalseStatement;
if (!IsEmpty(node.TrueStatement))
{
return(null);
}
}
contentStatement = GetSimpleStatement(contentStatement);
if (contentStatement == null)
{
return(null);
}
var leftExpressionPattern = PatternHelper.OptionalParentheses(comparedNode);
var expressionPattern = new AssignmentExpression(leftExpressionPattern, AssignmentOperatorType.Assign, new AnyNode(valueOnNullGroupName));
var statementPattern = new ExpressionStatement(PatternHelper.OptionalParentheses(expressionPattern));
var statementMatch = statementPattern.Match(contentStatement);
if (!statementMatch.Success)
{
return(null);
}
var rightSide = statementMatch.Get <Expression>(valueOnNullGroupName).Single();
return(new CodeAction(context.TranslateString("Convert if statement to ?? expression"),
script => {
var previousNode = node.GetPrevSibling(sibling => sibling is Statement);
var previousDeclaration = previousNode as VariableDeclarationStatement;
if (previousDeclaration != null && previousDeclaration.Variables.Count() == 1)
{
var variable = previousDeclaration.Variables.First();
var comparedNodeIdentifierExpression = comparedNode as IdentifierExpression;
if (comparedNodeIdentifierExpression != null &&
comparedNodeIdentifierExpression.Identifier == variable.Name)
{
script.Replace(variable.Initializer, new BinaryOperatorExpression(variable.Initializer.Clone(),
BinaryOperatorType.NullCoalescing,
rightSide.Clone()));
script.Remove(node);
return;
}
}
var previousExpressionStatement = previousNode as ExpressionStatement;
if (previousExpressionStatement != null)
{
var previousAssignment = previousExpressionStatement.Expression as AssignmentExpression;
if (previousAssignment != null &&
comparedNode.IsMatch(previousAssignment.Left))
{
var newExpression = new BinaryOperatorExpression(previousAssignment.Right.Clone(),
BinaryOperatorType.NullCoalescing,
rightSide.Clone());
script.Replace(previousAssignment.Right, newExpression);
script.Remove(node);
return;
}
}
var coalescedExpression = new BinaryOperatorExpression(comparedNode.Clone(),
BinaryOperatorType.NullCoalescing,
rightSide.Clone());
var newAssignment = new ExpressionStatement(new AssignmentExpression(comparedNode.Clone(), coalescedExpression));
script.Replace(node, newAssignment);
}, node));
}
public override object Visit (SimpleAssign simpleAssign)
{
var result = new AssignmentExpression ();
result.AssignmentOperatorType = AssignmentOperatorType.Assign;
if (simpleAssign.Target != null)
result.AddChild ((INode)simpleAssign.Target.Accept (this), AssignmentExpression.LeftExpressionRole);
result.AddChild (new CSharpTokenNode (Convert (simpleAssign.Location), 1), AssignmentExpression.OperatorRole);
if (simpleAssign.Source != null) {
result.AddChild ((INode)simpleAssign.Source.Accept (this), AssignmentExpression.RightExpressionRole);
}
return result;
}
public JsValue EvaluateAssignmentExpression(AssignmentExpression assignmentExpression)
{
var lref = EvaluateExpression(assignmentExpression.Left) as Reference;
JsValue rval = _engine.GetValue(EvaluateExpression(assignmentExpression.Right));
if (lref == null)
{
throw new JavaScriptException(_engine.ReferenceError);
}
if (assignmentExpression.Operator == AssignmentOperator.Assign) // "="
{
if (lref.IsStrict() && lref.GetBase().TryCast <EnvironmentRecord>() != null && (lref.GetReferencedName() == "eval" || lref.GetReferencedName() == "arguments"))
{
throw new JavaScriptException(_engine.SyntaxError);
}
_engine.PutValue(lref, rval);
return(rval);
}
JsValue lval = _engine.GetValue(lref);
switch (assignmentExpression.Operator)
{
case AssignmentOperator.PlusAssign:
var lprim = TypeConverter.ToPrimitive(lval);
var rprim = TypeConverter.ToPrimitive(rval);
if (lprim.IsString() || rprim.IsString())
{
lval = TypeConverter.ToString(lprim) + TypeConverter.ToString(rprim);
}
else
{
lval = TypeConverter.ToNumber(lprim) + TypeConverter.ToNumber(rprim);
}
break;
case AssignmentOperator.MinusAssign:
lval = TypeConverter.ToNumber(lval) - TypeConverter.ToNumber(rval);
break;
case AssignmentOperator.TimesAssign:
if (lval == Undefined.Instance || rval == Undefined.Instance)
{
lval = Undefined.Instance;
}
else
{
lval = TypeConverter.ToNumber(lval) * TypeConverter.ToNumber(rval);
}
break;
case AssignmentOperator.DivideAssign:
lval = Divide(lval, rval);
break;
case AssignmentOperator.ModuloAssign:
if (lval == Undefined.Instance || rval == Undefined.Instance)
{
lval = Undefined.Instance;
}
else
{
lval = TypeConverter.ToNumber(lval) % TypeConverter.ToNumber(rval);
}
break;
case AssignmentOperator.BitwiseAndAssign:
lval = TypeConverter.ToInt32(lval) & TypeConverter.ToInt32(rval);
break;
case AssignmentOperator.BitwiseOrAssign:
lval = TypeConverter.ToInt32(lval) | TypeConverter.ToInt32(rval);
break;
case AssignmentOperator.BitwiseXOrAssign:
lval = TypeConverter.ToInt32(lval) ^ TypeConverter.ToInt32(rval);
break;
case AssignmentOperator.LeftShiftAssign:
lval = TypeConverter.ToInt32(lval) << (int)(TypeConverter.ToUint32(rval) & 0x1F);
break;
case AssignmentOperator.RightShiftAssign:
lval = TypeConverter.ToInt32(lval) >> (int)(TypeConverter.ToUint32(rval) & 0x1F);
break;
case AssignmentOperator.UnsignedRightShiftAssign:
lval = (uint)TypeConverter.ToInt32(lval) >> (int)(TypeConverter.ToUint32(rval) & 0x1F);
break;
default:
throw new NotImplementedException();
}
_engine.PutValue(lref, lval);
return(lval);
}
public void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
StartNode(assignmentExpression);
assignmentExpression.Left.AcceptVisitor(this);
Space(policy.SpaceAroundAssignment);
WriteToken(AssignmentExpression.GetOperatorRole(assignmentExpression.Operator));
Space(policy.SpaceAroundAssignment);
assignmentExpression.Right.AcceptVisitor(this);
EndNode(assignmentExpression);
}
protected void VisitAssignmentExpression()
{
AssignmentExpression assignmentExpression = this.AssignmentExpression;
var oldAssigment = this.Emitter.IsAssignment;
var oldAssigmentType = this.Emitter.AssignmentType;
string variable = null;
bool needReturnValue = !(assignmentExpression.Parent is ExpressionStatement);
if (needReturnValue && assignmentExpression.Parent is LambdaExpression)
{
var lambdarr = this.Emitter.Resolver.ResolveNode(assignmentExpression.Parent, this.Emitter) as LambdaResolveResult;
if (lambdarr != null && lambdarr.ReturnType.Kind == TypeKind.Void)
{
needReturnValue = false;
}
}
var delegateAssigment = false;
bool isEvent = false;
var initCount = this.Emitter.Writers.Count;
var asyncExpressionHandling = this.Emitter.AsyncExpressionHandling;
this.WriteAwaiters(assignmentExpression.Left);
this.WriteAwaiters(assignmentExpression.Right);
var leftResolverResult = this.Emitter.Resolver.ResolveNode(assignmentExpression.Left, this.Emitter);
var rightResolverResult = this.Emitter.Resolver.ResolveNode(assignmentExpression.Right, this.Emitter);
var rr = this.Emitter.Resolver.ResolveNode(assignmentExpression, this.Emitter);
var orr = rr as OperatorResolveResult;
bool isDecimal = Helpers.IsDecimalType(rr.Type, this.Emitter.Resolver);
var expectedType = this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression);
bool isDecimalExpected = Helpers.IsDecimalType(expectedType, this.Emitter.Resolver);
bool isUserOperator = this.IsUserOperator(orr);
var charToString = -1;
if (orr != null && orr.Type.IsKnownType(KnownTypeCode.String))
{
for (int i = 0; i < orr.Operands.Count; i++)
{
var crr = orr.Operands[i] as ConversionResolveResult;
if (crr != null && crr.Input.Type.IsKnownType(KnownTypeCode.Char))
{
charToString = i;
}
}
}
if (needReturnValue)
{
variable = this.GetTempVarName();
this.Write("(" + variable + " = ");
var oldValue1 = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
assignmentExpression.Right.AcceptVisitor(this.Emitter);
this.Emitter.ReplaceAwaiterByVar = oldValue1;
this.Write(", ");
}
if (assignmentExpression.Operator == AssignmentOperatorType.Divide &&
(
(Helpers.IsIntegerType(leftResolverResult.Type, this.Emitter.Resolver) &&
Helpers.IsIntegerType(rightResolverResult.Type, this.Emitter.Resolver)) ||
(Helpers.IsIntegerType(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Left), this.Emitter.Resolver) &&
Helpers.IsIntegerType(this.Emitter.Resolver.Resolver.GetExpectedType(assignmentExpression.Right), this.Emitter.Resolver))
))
{
this.Emitter.IsAssignment = true;
this.Emitter.AssignmentType = AssignmentOperatorType.Assign;
var oldValue1 = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
assignmentExpression.Left.AcceptVisitor(this.Emitter);
if (this.Emitter.Writers.Count == initCount)
{
this.Write(" = ");
}
this.Emitter.ReplaceAwaiterByVar = oldValue1;
this.Emitter.AssignmentType = oldAssigmentType;
this.Emitter.IsAssignment = oldAssigment;
this.Write("Bridge.Int.div(");
assignmentExpression.Left.AcceptVisitor(this.Emitter);
this.Write(", ");
oldValue1 = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
if (needReturnValue)
{
this.Write(variable);
}
else
{
assignmentExpression.Right.AcceptVisitor(this.Emitter);
}
this.Write(")");
this.Emitter.ReplaceAwaiterByVar = oldValue1;
this.Emitter.AsyncExpressionHandling = asyncExpressionHandling;
if (this.Emitter.Writers.Count > initCount)
{
this.PopWriter();
}
return;
}
if (assignmentExpression.Operator == AssignmentOperatorType.Add ||
assignmentExpression.Operator == AssignmentOperatorType.Subtract)
{
var add = assignmentExpression.Operator == AssignmentOperatorType.Add;
if (this.Emitter.Validator.IsDelegateOrLambda(leftResolverResult))
{
delegateAssigment = true;
var leftMemberResolveResult = leftResolverResult as MemberResolveResult;
if (leftMemberResolveResult != null)
{
isEvent = leftMemberResolveResult.Member is DefaultResolvedEvent;
}
if (!isEvent)
{
this.Emitter.IsAssignment = true;
this.Emitter.AssignmentType = AssignmentOperatorType.Assign;
assignmentExpression.Left.AcceptVisitor(this.Emitter);
this.Emitter.IsAssignment = false;
if (this.Emitter.Writers.Count == initCount)
{
this.Write(" = ");
}
this.Write(Bridge.Translator.Emitter.ROOT + "." + (add ? Bridge.Translator.Emitter.DELEGATE_COMBINE : Bridge.Translator.Emitter.DELEGATE_REMOVE));
this.WriteOpenParentheses();
}
}
}
bool nullable = orr != null && orr.IsLiftedOperator;
string root = Bridge.Translator.Emitter.ROOT + ".Nullable.";
bool special = nullable;
this.Emitter.IsAssignment = true;
this.Emitter.AssignmentType = assignmentExpression.Operator;
var oldValue = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
bool thisAssignment = leftResolverResult is ThisResolveResult;
if (!thisAssignment)
{
if (special || (isDecimal && isDecimalExpected) || isUserOperator)
{
this.Emitter.AssignmentType = AssignmentOperatorType.Assign;
}
if (delegateAssigment && !isEvent)
{
this.Emitter.IsAssignment = false;
}
assignmentExpression.Left.AcceptVisitor(this.Emitter);
if (delegateAssigment)
{
this.Emitter.IsAssignment = true;
}
}
else
{
this.Write("(");
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AssignmentType = oldAssigmentType;
this.Emitter.IsAssignment = oldAssigment;
if (this.Emitter.Writers.Count == 0 && !delegateAssigment && !thisAssignment)
{
this.WriteSpace();
}
if (isDecimal && isDecimalExpected)
{
if (this.Emitter.Writers.Count == initCount)
{
this.Write(" = ");
}
this.HandleDecimal(rr, variable);
if (this.Emitter.Writers.Count > initCount)
{
this.PopWriter();
}
if (needReturnValue)
{
this.Write(", " + variable + ")");
}
return;
}
if (this.ResolveOperator(assignmentExpression, orr, initCount))
{
return;
}
if (!delegateAssigment)
{
if (!special)
{
switch (assignmentExpression.Operator)
{
case AssignmentOperatorType.Assign:
break;
case AssignmentOperatorType.Add:
this.Write("+");
break;
case AssignmentOperatorType.BitwiseAnd:
this.Write("&");
break;
case AssignmentOperatorType.BitwiseOr:
this.Write("|");
break;
case AssignmentOperatorType.Divide:
this.Write("/");
break;
case AssignmentOperatorType.ExclusiveOr:
this.Write("^");
break;
case AssignmentOperatorType.Modulus:
this.Write("%");
break;
case AssignmentOperatorType.Multiply:
this.Write("*");
break;
case AssignmentOperatorType.ShiftLeft:
this.Write("<<");
break;
case AssignmentOperatorType.ShiftRight:
this.Write(">>");
break;
case AssignmentOperatorType.Subtract:
this.Write("-");
break;
default:
throw new EmitterException(assignmentExpression,
"Unsupported assignment operator: " + assignmentExpression.Operator.ToString());
}
}
if (special)
{
if (this.Emitter.Writers.Count == initCount)
{
this.Write(" = ");
}
this.Write(root);
switch (assignmentExpression.Operator)
{
case AssignmentOperatorType.Assign:
break;
case AssignmentOperatorType.Add:
this.Write("add");
break;
case AssignmentOperatorType.BitwiseAnd:
this.Write("band");
break;
case AssignmentOperatorType.BitwiseOr:
this.Write("bor");
break;
case AssignmentOperatorType.Divide:
this.Write("div");
break;
case AssignmentOperatorType.ExclusiveOr:
this.Write("xor");
break;
case AssignmentOperatorType.Modulus:
this.Write("mod");
break;
case AssignmentOperatorType.Multiply:
this.Write("mul");
break;
case AssignmentOperatorType.ShiftLeft:
this.Write("sl");
break;
case AssignmentOperatorType.ShiftRight:
this.Write("sr");
break;
case AssignmentOperatorType.Subtract:
this.Write("sub");
break;
default:
throw new EmitterException(assignmentExpression,
"Unsupported assignment operator: " + assignmentExpression.Operator.ToString());
}
this.WriteOpenParentheses();
assignmentExpression.Left.AcceptVisitor(this.Emitter);
this.Write(", ");
}
int count = this.Emitter.Writers.Count;
if (count == 0 && !thisAssignment && !special)
{
this.Write("= ");
}
}
else if (!isEvent)
{
this.WriteComma();
}
oldValue = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
if (charToString == 1)
{
this.Write("String.fromCharCode(");
}
if (needReturnValue)
{
this.Write(variable);
}
else
{
assignmentExpression.Right.AcceptVisitor(this.Emitter);
}
if (charToString == 1)
{
this.Write(")");
}
if (special)
{
this.WriteCloseParentheses();
}
if (thisAssignment)
{
this.Write(").$clone(this)");
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.Emitter.AsyncExpressionHandling = asyncExpressionHandling;
if (this.Emitter.Writers.Count > initCount)
{
var writerCount = this.Emitter.Writers.Count;
for (int i = initCount; i < writerCount; i++)
{
this.PopWriter();
}
}
if (delegateAssigment)
{
this.WriteCloseParentheses();
}
if (needReturnValue)
{
this.Write(", " + variable + ")");
}
}
public override void VisitAssignmentExpression(AssignmentExpression assignmentExpression)
{
base.VisitAssignmentExpression(assignmentExpression);
// Only check the right side; The left side always has the type of
// the variable, which is not what we want to check
var rightResolveResult = context.Resolve(assignmentExpression.Right) as LocalResolveResult;
if (rightResolveResult != null) {
CheckForCriterion(assignmentExpression.Right, rightResolveResult.Variable);
}
}
public AssignmentBlock(IEmitter emitter, AssignmentExpression assignmentExpression)
: base(emitter, assignmentExpression)
{
this.Emitter = emitter;
this.AssignmentExpression = assignmentExpression;
}
