public void Visit(WhileStatement whileStatement)
{
using (Scope.Push(_mainType))
{
var tableArg = VisitChild(whileStatement.TableReference);
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "While_" + tableArg.MethodIdentifier;
method.Attributes = MemberAttributes.Private;
GenerateCallStatement(method.Statements, whileStatement.Line.Line);
var loop = new CodeIterationStatement();
loop.InitStatement = new CodeSnippetStatement();
loop.IncrementStatement = new CodeSnippetStatement();
loop.TestExpression = new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(tableArg.CodeExpression, "RowCount"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(0));
method.Statements.Add(loop);
var blockArgs = VisitChild(whileStatement.Block, new CodeDomArg() { Tag = true });
loop.Statements.AddRange(blockArgs.ParentStatements);
var methodcall = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(null, method.Name));
_mainType.Type.Members.Add(method);
_codeStack.Peek().ParentStatements.Add(methodcall);
_codeStack.Peek().CodeExpression = methodcall;
}
}
void EmitIterationStatement(CodeIterationStatement Iterate)
{
Depth++;
Debug("Emitting iteration statement");
// Used for break and continue later on
var Meta = new LoopMetadata {
Begin = Generator.DefineLabel(),
End = Generator.DefineLabel(),
};
Loops.Push(Meta);
EmitStatement(Iterate.InitStatement, false);
// The beginning of our loop: check the limit
Generator.MarkLabel(Meta.Begin);
EmitExpression(Iterate.TestExpression, false);
Generator.Emit(OpCodes.Brfalse, Meta.End);
// Emit the actual statements within
EmitStatementCollection(Iterate.Statements);
// Increase the counter by one
EmitStatement(Iterate.IncrementStatement, false);
// Start all over again
Generator.Emit(OpCodes.Br, Meta.Begin);
Generator.MarkLabel(Meta.End);
Loops.Pop();
Depth--;
}
public void BeginLoop()
{
var cond = new CodeBinaryOperatorExpression(_expr_memory_pointer, CodeBinaryOperatorType.IdentityInequality, _expr_value_zero);
var loop = new CodeIterationStatement(new CodeSnippetStatement(), cond, new CodeSnippetStatement());
_nest.Peek().Add(loop);
_nest.Push(loop.Statements);
IncrementInstructionPointer();
}
public void Constructor0_Deny_Unrestricted ()
{
CodeIterationStatement cis = new CodeIterationStatement ();
Assert.IsNull (cis.IncrementStatement, "IncrementStatement");
cis.IncrementStatement = new CodeStatement ();
Assert.IsNull (cis.InitStatement, "InitStatement");
cis.InitStatement = new CodeStatement ();
Assert.AreEqual (0, cis.Statements.Count, "Statements");
Assert.IsNull (cis.TestExpression, "TestExpression");
cis.TestExpression = new CodeExpression ();
}
public TypescriptIterationStatement(
IStatementFactory statementFactory,
IExpressionFactory expressionFactory,
CodeIterationStatement statement,
CodeGeneratorOptions options)
{
_statementFactory = statementFactory;
_expressionFactory = expressionFactory;
_statement = statement;
_options = options;
}
// Emit a codedome expression representing a while loop.
public static CodeStatement Emit(WhileLoop loop)
{
// A while loop is a for loop with no initializer or incrementor, only a condition.
var i = new CodeIterationStatement(new CodeSnippetStatement(""),
CodeDomEmitter.EmitCodeExpression(loop.Condition.ChildExpressions[0]),
new CodeSnippetStatement(""));
// Emit the statements found in the body of the while loop.
foreach (var e in loop.ChildExpressions)
i.Statements.Add(CodeDomEmitter.EmitCodeStatement(e));
return i;
}
public void Visit(EachStatement eachStatement)
{
using (Scope.Push(_mainType))
{
var iterationArg = VisitChild(eachStatement.IterationVariable);
var tableArg = VisitChild(eachStatement.TableReference);
var rowType = iterationArg.Scope.CodeDomReference;
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "Each_" + iterationArg.MethodIdentifier;
method.Attributes = MemberAttributes.Private;
GenerateCallStatement(method.Statements, eachStatement.Line.Line);
var progressInc = new CodeAssignStatement(new CodePropertyReferenceExpression(null, "TotalOperations"),
new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(null, "TotalOperations"),
CodeBinaryOperatorType.Add,
new CodePropertyReferenceExpression(tableArg.CodeExpression, "RowCount"))
);
method.Statements.Add(progressInc);
method.Statements.Add(
new CodeVariableDeclarationStatement(new CodeTypeReference("IEnumerator", rowType),
"x",
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(tableArg.CodeExpression, "GetCopyEnumerator",
null)))
);
var loop = new CodeIterationStatement();
loop.InitStatement = new CodeSnippetStatement();
loop.IncrementStatement = new CodeSnippetStatement();
loop.TestExpression = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression("x"), "MoveNext",
null));
var rowReference = VisitChild(new TableVariableRowReference() { Id = eachStatement.IterationVariable.Variable, Line = eachStatement.IterationVariable.Line });
loop.Statements.Add(new CodeAssignStatement(rowReference.CodeExpression, new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("x"), "Current")));
var blockArgs = VisitChild(eachStatement.Block, new CodeDomArg() { Tag = true });
loop.Statements.AddRange(blockArgs.ParentStatements);
CallOnProgress(loop.Statements, false);
method.Statements.Add(loop);
var methodcall = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(null, method.Name));
_mainType.Type.Members.Add(method);
_codeStack.Peek().ParentStatements.Add(methodcall);
_codeStack.Peek().CodeExpression = methodcall;
}
}
public static CodeIterationStatement Clone(this CodeIterationStatement statement)
{
if (statement == null) return null;
CodeIterationStatement s = new CodeIterationStatement();
s.EndDirectives.AddRange(statement.EndDirectives);
s.IncrementStatement = statement.IncrementStatement.Clone();
s.InitStatement = statement.InitStatement.Clone();
s.LinePragma = statement.LinePragma;
s.StartDirectives.AddRange(statement.StartDirectives);
s.Statements.AddRange(statement.Statements.Clone());
s.TestExpression = statement.TestExpression.Clone();
s.UserData.AddRange(statement.UserData);
return s;
}
public void Constructor1_Deny_Unrestricted ()
{
CodeStatement init = new CodeStatement ();
CodeExpression test = new CodeExpression ();
CodeStatement increment = new CodeStatement ();
CodeStatement[] statements = new CodeStatement[2] { init, increment };
CodeIterationStatement cis = new CodeIterationStatement (init, test, increment, statements);
Assert.AreSame (increment, cis.IncrementStatement, "IncrementStatement");
cis.IncrementStatement = new CodeStatement ();
Assert.AreSame (init, cis.InitStatement, "InitStatement");
cis.InitStatement = new CodeStatement ();
Assert.AreEqual (2, cis.Statements.Count, "Statements");
Assert.AreSame (test, cis.TestExpression, "TestExpression");
cis.TestExpression = new CodeExpression ();
}
public void GetKeywordFromCodeDom()
{
CodeStatement st = new CodeExpressionStatement(new CodeArgumentReferenceExpression("foo"));
CodeExpression exp = new CodeArgumentReferenceExpression("foo");
CodeIterationStatement it = new CodeIterationStatement(st, exp, st);
CodeConditionStatement cond = new CodeConditionStatement(exp);
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromStatement(
it, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions());
new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromStatement(
cond, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions());
new Microsoft.VisualBasic.VBCodeProvider().GenerateCodeFromStatement(
it, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions());
new Microsoft.VisualBasic.VBCodeProvider().GenerateCodeFromStatement(
cond, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions());
}
private CodeIterationStatement GenerateForLoop(GroupActivity groupActivity)
{
var coreGroupMethodStatement = new CodeStatementCollection();
// put the current element in the declare variable
// TODO convert the $Variable in variable like in Xpath
CodeVariableDeclarationStatement iterationElementSlotDeclaration = new CodeVariableDeclarationStatement("var", groupActivity.IterationElementSlot, new CodeVariableReferenceExpression(groupActivity.Over + "[" + groupActivity.IndexSlot + "]"));
coreGroupMethodStatement.Add(iterationElementSlotDeclaration);
// get the core loop code
coreGroupMethodStatement.AddRange(this.GenerateCoreGroupMethod(groupActivity));
var array = new CodeStatement[coreGroupMethodStatement.Count];
coreGroupMethodStatement.CopyTo(array, 0);
// put it then in the loop
CodeIterationStatement forLoop = new CodeIterationStatement(new CodeVariableDeclarationStatement(typeof(int), groupActivity.IndexSlot, new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(groupActivity.IndexSlot), CodeBinaryOperatorType.LessThan, new CodeVariableReferenceExpression(groupActivity.Over + ".Lenght")),
new CodeAssignStatement(new CodeVariableReferenceExpression(groupActivity.IndexSlot), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(groupActivity.IndexSlot), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
array);
return forLoop;
}
public void Visit(ExpandExpression expression)
{
var fromDomArgs = VisitChild(expression.From);
var toDomArgs = VisitChild(expression.To);
var expressionArgs = VisitChild(expression.Expression);
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "Expand_" + fromDomArgs.MethodIdentifier;
method.Attributes = MemberAttributes.Private;
method.ReturnType = new CodeTypeReference("Table", new CodeTypeReference("Expand"));
method.Statements.Add(new CodeVariableDeclarationStatement(method.ReturnType, "expandTable",
new CodeObjectCreateExpression(new CodeTypeReference("RuntimeTable", new CodeTypeReference("Expand")))));
method.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "x"));
var loop = new CodeIterationStatement();
loop.InitStatement = new CodeAssignStatement( new CodeVariableReferenceExpression("x"), fromDomArgs.CodeExpression);
loop.TestExpression = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression("x"),
CodeBinaryOperatorType.LessThanOrEqual, toDomArgs.CodeExpression);
loop.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression("x"), new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("x"), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1)));
loop.Statements.Add(new CodeVariableDeclarationStatement("Expand", "expand", new CodeObjectCreateExpression("Expand")));
loop.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeVariableReferenceExpression("expand"), "value"),
expressionArgs.CodeExpression));
loop.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("expandTable"), "Add",
new CodeVariableReferenceExpression("expand")));
method.Statements.Add(loop);
method.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("expandTable")));
_mainType.Type.Members.Add(method);
var methodcall = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(null, method.Name));
_codeStack.Peek().CodeExpression = methodcall;
_codeStack.Peek().Scope = new ScopeData<TableDescriptor> { Type = Expand.Columns, CodeDomReference = method.ReturnType };
}
void EmitIteration(CodeIterationStatement iteration)
{
EmitStatement(iteration.InitStatement);
WriteSpace();
writer.Write(Parser.FlowWhile);
writer.Write(Parser.ParenOpen);
depth++;
EmitExpression(iteration.TestExpression);
depth--;
writer.Write(Parser.ParenClose);
WriteSpace();
writer.Write(Parser.BlockOpen);
depth++;
EmitStatements(iteration.Statements);
EmitStatement(iteration.IncrementStatement);
depth--;
WriteSpace();
writer.Write(Parser.BlockClose);
}
// RG:
public override object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data)
{
CodeIterationStatement forLoop = new CodeIterationStatement();
breakableStack.Push(new Breakable());
codeStack.Push(NullStmtCollection);
if (doLoopStatement.ConditionPosition == ConditionPosition.End)
{
// do { } while (expr);
//
// emulate with:
// for (bool _do = true; _do; _do = expr) {}
//
doId++;
string name = "_do" + doId;
forLoop.InitStatement = new CodeVariableDeclarationStatement(typeof(System.Boolean), name, new CodePrimitiveExpression(true));
forLoop.TestExpression = new CodeVariableReferenceExpression(name);
forLoop.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(name),
doLoopStatement.Condition == null ? new CodePrimitiveExpression(true) : (CodeExpression)doLoopStatement.Condition.AcceptVisitor(this, data));
}
else
{
// while (expr) {}
//
// emulate with:
// for (; expr;) {}
//
// Empty Init and Increment Statements
forLoop.InitStatement = new CodeExpressionStatement(new CodeSnippetExpression());
forLoop.IncrementStatement = new CodeExpressionStatement(new CodeSnippetExpression());
if (doLoopStatement.Condition == null)
{
forLoop.TestExpression = new CodePrimitiveExpression(true);
}
else
{
forLoop.TestExpression = (CodeExpression)doLoopStatement.Condition.AcceptVisitor(this, data);
}
}
codeStack.Pop();
codeStack.Push(forLoop.Statements);
doLoopStatement.EmbeddedStatement.AcceptVisitor(this, data);
codeStack.Pop();
if (forLoop.Statements.Count == 0)
{
forLoop.Statements.Add(new CodeSnippetStatement());
}
Breakable breakable = breakableStack.Pop();
if (breakable.IsContinue)
{
forLoop.Statements.Add(new CodeSnippetStatement());
forLoop.Statements.Add(new CodeLabeledStatement("continue" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
}
AddStmt(forLoop);
if (breakable.IsBreak)
{
AddStmt(new CodeLabeledStatement("break" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
}
return forLoop;
}
protected override void GenerateIterationStatement(CodeIterationStatement e)
{
base.GenerateStatement(e.InitStatement);
base.Output.Write("Do While ");
base.GenerateExpression(e.TestExpression);
base.Output.WriteLine("");
base.Indent++;
this.GenerateVBStatements(e.Statements);
base.GenerateStatement(e.IncrementStatement);
base.Indent--;
base.Output.WriteLine("Loop");
}
private void CreateGetLoginsMethod(CodeTypeDeclaration type)
{
CodeMemberMethod method = new CodeMemberMethod();
CodeTypeReference returnType = CreateTaskTypeReference();
returnType.TypeArguments.Add(CodeDomUtilities.GetGenericType(typeof(IList<>), "Microsoft.AspNet.Identity.UserLoginInfo"));
method.ReturnType = returnType;
method.Attributes = MemberAttributes.Public;
method.Name = "GetLoginsAsync";
method.Parameters.Add(new CodeParameterDeclarationExpression(IdentityUser.ClrFullTypeName, "user"));
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserLoginStore", false));
if (CanImplementGenericInterfaces)
{
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserLoginStore", true));
}
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("user"));
method.Statements.Add(new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IList<>), "Microsoft.AspNet.Identity.UserLoginInfo"), "result", new CodeObjectCreateExpression(CodeDomUtilities.GetGenericType(typeof(List<>), "Microsoft.AspNet.Identity.UserLoginInfo"))));
var enumerator = new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IEnumerator<>), IdentityUserLogin.ClrFullTypeName), "enumerator");
enumerator.InitExpression = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("user"), IdentityUser.LoginsProperty.Name), "GetEnumerator");
var iteration = new CodeIterationStatement();
iteration.InitStatement = enumerator;
iteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("enumerator"), "MoveNext");
iteration.IncrementStatement = new CodeSnippetStatement("");
iteration.Statements.Add(new CodeVariableDeclarationStatement(IdentityUserLogin.ClrFullTypeName, "userLogin", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("enumerator"), "Current")));
// V1 & V2: public UserLoginInfo(string loginProvider, string providerKey)
// V3: public UserLoginInfo(string loginProvider, string providerKey, string displayName)
var createExpression = new CodeObjectCreateExpression("Microsoft.AspNet.Identity.UserLoginInfo");
if (IdentityUserLogin.ProviderNameProperty != null)
{
createExpression.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userLogin"), IdentityUserLogin.ProviderNameProperty.Name));
}
else
{
createExpression.Parameters.Add(new CodePrimitiveExpression(null));
}
createExpression.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userLogin"), IdentityUserLogin.ProviderKeyProperty.Name));
if (IdentityProducer.TargetVersion == AspNetIdentityVersion.Version3)
{
if (IdentityUserLogin.ProviderDisplayNameProperty != null)
{
createExpression.Parameters.Add(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userLogin"), IdentityUserLogin.ProviderDisplayNameProperty.Name));
}
else
{
createExpression.Parameters.Add(new CodePrimitiveExpression(null));
}
}
iteration.Statements.Add(
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("result"), "Add",
createExpression));
method.Statements.Add(iteration);
method.Statements.Add(CreateTaskResult(new CodeVariableReferenceExpression("result")));
type.Members.Add(method);
}
private void CreateGetClaimsMethod(CodeTypeDeclaration type)
{
CodeMemberMethod method = new CodeMemberMethod();
var returnType = CreateTaskTypeReference();
returnType.TypeArguments.Add(CodeDomUtilities.GetGenericType(typeof(IList<>), ClaimFullTypeName));
method.ReturnType = returnType;
method.Attributes = MemberAttributes.Public;
method.Name = "GetClaimsAsync";
method.Parameters.Add(new CodeParameterDeclarationExpression(IdentityUser.ClrFullTypeName, "user"));
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserClaimStore", false));
if (CanImplementGenericInterfaces)
{
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserClaimStore", true));
}
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("user"));
method.Statements.Add(new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IList<>), ClaimFullTypeName), "result", new CodeObjectCreateExpression(CodeDomUtilities.GetGenericType(typeof(List<>), ClaimFullTypeName))));
var enumerator = new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IEnumerator<>), IdentityUserClaim.ClrFullTypeName), "enumerator");
enumerator.InitExpression = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("user"), IdentityUser.ClaimsProperty.Name), "GetEnumerator");
var iteration = new CodeIterationStatement();
iteration.InitStatement = enumerator;
iteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("enumerator"), "MoveNext");
iteration.IncrementStatement = new CodeSnippetStatement("");
iteration.Statements.Add(new CodeVariableDeclarationStatement(IdentityUserClaim.ClrFullTypeName, "userClaim", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("enumerator"), "Current")));
var createExpression = new CodeObjectCreateExpression(ClaimFullTypeName);
if (IdentityUserClaim.OriginalIssuerProperty != null)
{
createExpression.Parameters.Insert(0, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.OriginalIssuerProperty.Name));
}
if (IdentityUserClaim.IssuerProperty != null)
{
createExpression.Parameters.Insert(0, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.IssuerProperty.Name));
}
else if (createExpression.Parameters.Count > 0)
{
createExpression.Parameters.Insert(0, createExpression.Parameters[0]); // OriginalIssuer
}
if (IdentityUserClaim.ValueTypeProperty != null)
{
createExpression.Parameters.Insert(0, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.ValueTypeProperty.Name));
}
else if (createExpression.Parameters.Count > 0)
{
createExpression.Parameters.Insert(0, new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(ClaimValueTypesFullTypeName), "String"));
}
createExpression.Parameters.Insert(0, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.ValueProperty.Name));
createExpression.Parameters.Insert(0, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.TypeProperty.Name));
iteration.Statements.Add(
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("result"), "Add",
createExpression));
method.Statements.Add(iteration);
method.Statements.Add(CreateTaskResult(new CodeVariableReferenceExpression("result")));
type.Members.Add(method);
}
private void CreateAddClaimsMethod(CodeTypeDeclaration type)
{
CodeMemberMethod method = new CodeMemberMethod();
method.ReturnType = CreateTaskTypeReference();
method.Attributes = MemberAttributes.Public;
method.Name = "AddClaimsAsync";
method.Parameters.Add(new CodeParameterDeclarationExpression(IdentityUser.ClrFullTypeName, "user"));
method.Parameters.Add(new CodeParameterDeclarationExpression(CodeDomUtilities.GetGenericType(typeof(IEnumerable<>), ClaimFullTypeName), "claims"));
if (IdentityProducer.TargetVersion == AspNetIdentityVersion.Version3)
{
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserClaimStore", false));
}
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("user"));
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("claims"));
var enumerator = new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IEnumerator<>), ClaimFullTypeName), "enumerator");
enumerator.InitExpression = new CodeMethodInvokeExpression(new CodeArgumentReferenceExpression("claims"), "GetEnumerator");
var iteration = new CodeIterationStatement();
iteration.InitStatement = enumerator;
iteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("enumerator"), "MoveNext");
iteration.IncrementStatement = new CodeSnippetStatement("");
iteration.Statements.Add(new CodeVariableDeclarationStatement(ClaimFullTypeName, "claim", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("enumerator"), "Current")));
method.Statements.Add(iteration);
Func<string, CodeExpression> claimProperty = propertyName => new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("claim"), propertyName);
AddCreateUserClaimFromClaim(iteration.Statements, claimProperty);
method.Statements.Add(CreateEmptyTaskResult());
type.Members.Add(method);
}
private void AddRemoveUserClaimFromClaim(CodeMemberMethod method, CodeStatementCollection statements, Func<string, CodeExpression> getClaimProperty)
{
bool useMethod = false;
if (IdentityUserClaim.DeleteClaimsMethod != null)
{
CodeMethodInvokeExpression invokeMethod = CreateMethodInvokeExpression(IdentityUserClaim.Entity, IdentityUserClaim.DeleteClaimsMethod);
foreach (var parameter in IdentityUserClaim.DeleteClaimsMethod.Parameters)
{
if (parameter.ProjectProperty == IdentityUserClaim.UserProperty)
{
invokeMethod.Parameters.Add(new CodeArgumentReferenceExpression("user"));
}
else if (parameter.ProjectProperty == IdentityUserClaim.TypeProperty)
{
invokeMethod.Parameters.Add(getClaimProperty("Type"));
}
else if (parameter.ProjectProperty == IdentityUserClaim.ValueProperty)
{
invokeMethod.Parameters.Add(getClaimProperty("Value"));
}
else if (parameter.ProjectProperty == IdentityUserClaim.ValueTypeProperty)
{
invokeMethod.Parameters.Add(getClaimProperty("ValueType"));
}
else if (parameter.ProjectProperty == IdentityUserClaim.IssuerProperty)
{
invokeMethod.Parameters.Add(getClaimProperty("Issuer"));
}
else if (parameter.ProjectProperty == IdentityUserClaim.OriginalIssuerProperty)
{
invokeMethod.Parameters.Add(getClaimProperty("OriginalIssuer"));
}
else
{
invokeMethod = null;
break;
}
}
if (invokeMethod != null)
{
statements.Add(invokeMethod);
useMethod = true;
}
}
if (!useMethod)
{
/*
List<UserClaim> toDelete = new List<UserClaim>();
foreach (var userClaim in user.Claims)
{
if (userClaim.Equals(claim))
{
toDelete.Add(userClaim);
}
}*/
statements.Add(new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IList<>), IdentityUserClaim.ClrFullTypeName), "toDelete", new CodeObjectCreateExpression(CodeDomUtilities.GetGenericType(typeof(List<>), IdentityUserClaim.ClrFullTypeName))));
var userClaimsEnumerator = CodeDomUtilities.GetUniqueVariable(method, CodeDomUtilities.GetGenericType(typeof(IEnumerator<>), IdentityUserClaim.ClrFullTypeName), "enumerator");
userClaimsEnumerator.InitExpression = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("user"), IdentityUser.ClaimsProperty.Name), "GetEnumerator");
var userClaimsIteration = new CodeIterationStatement();
userClaimsIteration.InitStatement = userClaimsEnumerator;
userClaimsIteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(userClaimsEnumerator.Name), "MoveNext");
userClaimsIteration.IncrementStatement = new CodeSnippetStatement("");
statements.Add(userClaimsIteration);
userClaimsIteration.Statements.Add(new CodeVariableDeclarationStatement(IdentityUserClaim.ClrFullTypeName, "userClaim", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(userClaimsEnumerator.Name), "Current")));
CodeConditionStatement claimsEqual = new CodeConditionStatement();
userClaimsIteration.Statements.Add(claimsEqual);
claimsEqual.Condition = CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.TypeProperty.Name),
getClaimProperty("Type"));
if (IdentityUserClaim.ValueProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, true))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd, CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.ValueProperty.Name),
getClaimProperty("Value")));
}
if (IdentityUserClaim.ValueTypeProperty != null && IdentityUserClaim.ValueTypeProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, false))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.ValueTypeProperty.Name),
getClaimProperty("ValueType")));
}
if (IdentityUserClaim.IssuerProperty != null && IdentityUserClaim.IssuerProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, false))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.IssuerProperty.Name),
getClaimProperty("Issuer")));
}
if (IdentityUserClaim.OriginalIssuerProperty != null && IdentityUserClaim.OriginalIssuerProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, false))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.OriginalIssuerProperty.Name),
getClaimProperty("OriginalIssuer")));
}
claimsEqual.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("toDelete"), "Add", new CodeVariableReferenceExpression("userClaim")));
/*
foreach (var userClaim in toDelete)
{
userClaim.Delete();
user.Claims.Remove(userClaim);
}
*/
var toDeleteEnumerator = CodeDomUtilities.GetUniqueVariable(method, CodeDomUtilities.GetGenericType(typeof(IEnumerator<>), IdentityUserClaim.ClrFullTypeName), "enumerator");
toDeleteEnumerator.InitExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("toDelete"), "GetEnumerator");
var toDeleteIteration = new CodeIterationStatement();
toDeleteIteration.InitStatement = toDeleteEnumerator;
toDeleteIteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(toDeleteEnumerator.Name), "MoveNext");
toDeleteIteration.IncrementStatement = new CodeSnippetStatement("");
statements.Add(toDeleteIteration);
toDeleteIteration.Statements.Add(new CodeVariableDeclarationStatement(IdentityUserClaim.ClrFullTypeName, "userClaim", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(toDeleteEnumerator.Name), "Current")));
toDeleteIteration.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("userClaim"), "Delete"));
toDeleteIteration.Statements.Add(new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("user"), IdentityUser.ClaimsProperty.Name), "Remove", new CodeVariableReferenceExpression("userClaim")));
}
}
private void CreateReplaceClaimMethod(CodeTypeDeclaration type)
{
CodeMemberMethod method = new CodeMemberMethod();
method.ReturnType = CreateTaskTypeReference();
method.Attributes = MemberAttributes.Public;
method.Name = "ReplaceClaimAsync";
method.Parameters.Add(new CodeParameterDeclarationExpression(IdentityUser.ClrFullTypeName, "user"));
method.Parameters.Add(new CodeParameterDeclarationExpression(ClaimFullTypeName, "oldClaim"));
method.Parameters.Add(new CodeParameterDeclarationExpression(ClaimFullTypeName, "newClaim"));
if (IdentityProducer.TargetVersion == AspNetIdentityVersion.Version3)
{
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserClaimStore", false));
}
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("user"));
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("oldClaim"));
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("newClaim"));
var userClaimsEnumerator = new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IEnumerator<>), IdentityUserClaim.ClrFullTypeName), "enumerator");
userClaimsEnumerator.InitExpression = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("user"), IdentityUser.ClaimsProperty.Name), "GetEnumerator");
var userClaimsIteration = new CodeIterationStatement();
userClaimsIteration.InitStatement = userClaimsEnumerator;
userClaimsIteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("enumerator"), "MoveNext");
userClaimsIteration.IncrementStatement = new CodeSnippetStatement("");
method.Statements.Add(userClaimsIteration);
userClaimsIteration.Statements.Add(new CodeVariableDeclarationStatement(IdentityUserClaim.ClrFullTypeName, "userClaim", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("enumerator"), "Current")));
CodeConditionStatement claimsEqual = new CodeConditionStatement();
userClaimsIteration.Statements.Add(claimsEqual);
claimsEqual.Condition = CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.TypeProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("oldClaim"), "Type"));
if (IdentityUserClaim.ValueProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, true))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd, CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.ValueProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("oldClaim"), "Value")));
}
if (IdentityUserClaim.ValueTypeProperty != null && IdentityUserClaim.ValueTypeProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, false))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.ValueTypeProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("oldClaim"), "ValueType")));
}
if (IdentityUserClaim.IssuerProperty != null && IdentityUserClaim.IssuerProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, false))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.IssuerProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("oldClaim"), "Issuer")));
}
if (IdentityUserClaim.OriginalIssuerProperty != null && IdentityUserClaim.OriginalIssuerProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, false))
{
claimsEqual.Condition = new CodeBinaryOperatorExpression(claimsEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userClaim"), IdentityUserClaim.OriginalIssuerProperty.Name),
new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("oldClaim"), "OriginalIssuer")));
}
// Replace userClaim properties & Save
AddSetAndSaveUserClaimFromClaim(
claimsEqual.TrueStatements,
new CodeVariableReferenceExpression("userClaim"),
propertyName => new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("newClaim"), propertyName));
method.Statements.Add(CreateEmptyTaskResult());
type.Members.Add(method);
}
private void CreateRemoveLoginMethod(CodeTypeDeclaration type)
{
CodeMemberMethod method = new CodeMemberMethod();
method.ReturnType = CreateTaskTypeReference();
method.Attributes = MemberAttributes.Public;
method.Name = "RemoveLoginAsync";
method.Parameters.Add(new CodeParameterDeclarationExpression(IdentityUser.ClrFullTypeName, "user"));
if (IdentityProducer.TargetVersion == AspNetIdentityVersion.Version3)
{
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "loginProvider"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "providerKey"));
}
else
{
method.Parameters.Add(new CodeParameterDeclarationExpression("Microsoft.AspNet.Identity.UserLoginInfo", "userLoginInfo"));
}
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserLoginStore", false));
if (CanImplementGenericInterfaces)
{
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserLoginStore", true));
}
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("user"));
if (IdentityProducer.TargetVersion != AspNetIdentityVersion.Version3)
{
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("userLoginInfo"));
}
bool useMethod = false;
if (IdentityUserLogin.DeleteByUserLoginInfoMethod != null)
{
if (IdentityUserLogin.DeleteByUserLoginInfoMethod.Parameters.Count == 2)
{
method.Statements.Add(CreateMethodInvokeExpression(IdentityUserLogin.Entity, IdentityUserLogin.DeleteByUserLoginInfoMethod,
new CodeArgumentReferenceExpression("user"),
GetLoginProviderKeyExpression()));
useMethod = true;
}
else if (IdentityUserLogin.DeleteByUserLoginInfoMethod.Parameters.Count == 3)
{
method.Statements.Add(CreateMethodInvokeExpression(IdentityUserLogin.Entity, IdentityUserLogin.DeleteByUserLoginInfoMethod,
new CodeArgumentReferenceExpression("user"),
GetLoginProviderKeyExpression(),
GetLoginProviderNameExpression()));
useMethod = true;
}
}
if (!useMethod)
{
/*
List<UserLogin> toDelete = new List<UserLogin>();
foreach (var userLogin in user.Logins)
{
if (userLogin.Equals(userLoginInfo))
{
toDelete.Add(userLogin);
}
}*/
method.Statements.Add(new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IList<>), IdentityUserLogin.ClrFullTypeName), "toDelete", new CodeObjectCreateExpression(CodeDomUtilities.GetGenericType(typeof(List<>), IdentityUserLogin.ClrFullTypeName))));
var userLoginsEnumerator = CodeDomUtilities.GetUniqueVariable(method, CodeDomUtilities.GetGenericType(typeof(IEnumerator<>), IdentityUserLogin.ClrFullTypeName), "enumerator");
userLoginsEnumerator.InitExpression = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("user"), IdentityUser.LoginsProperty.Name), "GetEnumerator");
var userLoginsIteration = new CodeIterationStatement();
userLoginsIteration.InitStatement = userLoginsEnumerator;
userLoginsIteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(userLoginsEnumerator.Name), "MoveNext");
userLoginsIteration.IncrementStatement = new CodeSnippetStatement("");
method.Statements.Add(userLoginsIteration);
userLoginsIteration.Statements.Add(new CodeVariableDeclarationStatement(IdentityUserLogin.ClrFullTypeName, "userLogin", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(userLoginsEnumerator.Name), "Current")));
CodeConditionStatement loginEqual = new CodeConditionStatement();
userLoginsIteration.Statements.Add(loginEqual);
loginEqual.Condition = CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userLogin"), IdentityUserLogin.ProviderKeyProperty.Name),
GetLoginProviderKeyExpression());
if (IdentityUserLogin.ProviderNameProperty != null && IdentityUserLogin.ProviderNameProperty.GetAttributeValue("isComparer", Constants.NamespaceUri, true))
{
loginEqual.Condition = new CodeBinaryOperatorExpression(loginEqual.Condition, CodeBinaryOperatorType.BooleanAnd,
CreateStringEqualsExpression(StringComparison.OrdinalIgnoreCase,
new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("userLogin"), IdentityUserLogin.ProviderNameProperty.Name),
GetLoginProviderNameExpression()));
}
loginEqual.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("toDelete"), "Add", new CodeVariableReferenceExpression("userLogin")));
/*
foreach (var userLogin in toDelete)
{
userLogin.Delete();
user.Logins.Remove(userLogin);
}
*/
var toDeleteEnumerator = CodeDomUtilities.GetUniqueVariable(method, CodeDomUtilities.GetGenericType(typeof(IEnumerator<>), IdentityUserLogin.ClrFullTypeName), "enumerator");
toDeleteEnumerator.InitExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("toDelete"), "GetEnumerator");
var toDeleteIteration = new CodeIterationStatement();
toDeleteIteration.InitStatement = toDeleteEnumerator;
toDeleteIteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(toDeleteEnumerator.Name), "MoveNext");
toDeleteIteration.IncrementStatement = new CodeSnippetStatement("");
method.Statements.Add(toDeleteIteration);
toDeleteIteration.Statements.Add(new CodeVariableDeclarationStatement(IdentityUserLogin.ClrFullTypeName, "userLogin", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression(toDeleteEnumerator.Name), "Current")));
toDeleteIteration.Statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("userLogin"), "Delete"));
toDeleteIteration.Statements.Add(new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("user"), IdentityUser.LoginsProperty.Name), "Remove", new CodeVariableReferenceExpression("userLogin")));
}
method.Statements.Add(CreateEmptyTaskResult());
type.Members.Add(method);
}
private void CreateGetRolesMethod(CodeTypeDeclaration type)
{
CodeMemberMethod method = new CodeMemberMethod();
CodeTypeReference returnType = CreateTaskTypeReference();
returnType.TypeArguments.Add(CodeDomUtilities.GetGenericType(typeof(IList<>), typeof(string)));
method.ReturnType = returnType;
method.Attributes = MemberAttributes.Public;
method.Name = "GetRolesAsync";
method.Parameters.Add(new CodeParameterDeclarationExpression(IdentityUser.ClrFullTypeName, "user"));
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserRoleStore", false));
if (CanImplementGenericInterfaces)
{
method.ImplementationTypes.Add(GetGenericInterfaceType("Microsoft.AspNet.Identity.IUserRoleStore", true));
}
method.Statements.Add(CodeDomUtilities.CreateParameterThrowIfNull("user"));
method.Statements.Add(new CodeVariableDeclarationStatement(typeof(IList<>).MakeGenericType(typeof(string)), "roleNames", new CodeObjectCreateExpression(typeof(List<>).MakeGenericType(typeof(string)))));
var enumerator = new CodeVariableDeclarationStatement(CodeDomUtilities.GetGenericType(typeof(IEnumerator<>), IdentityRole.ClrFullTypeName), "enumerator");
enumerator.InitExpression = new CodeMethodInvokeExpression(new CodePropertyReferenceExpression(new CodeArgumentReferenceExpression("user"), IdentityUser.RolesProperty.Name), "GetEnumerator");
var iteration = new CodeIterationStatement();
iteration.InitStatement = enumerator;
iteration.TestExpression = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("enumerator"), "MoveNext");
iteration.IncrementStatement = new CodeSnippetStatement("");
iteration.Statements.Add(
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("roleNames"), "Add",
new CodePropertyReferenceExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("enumerator"), "Current"), IdentityRole.NameProperty.Name)));
method.Statements.Add(iteration);
method.Statements.Add(CreateTaskResult(new CodeVariableReferenceExpression("roleNames")));
type.Members.Add(method);
}
protected override void GenerateIterationStatement (CodeIterationStatement e)
{
}
private static CodeStatement LoopThroughArray(CodeExpression array, CodeStatementCollection statements)
{
var returnValue = new CodeIterationStatement
{
InitStatement =
new CodeAssignStatement(new CodeVariableReferenceExpression("index"), new CodePrimitiveExpression(0)),
TestExpression = new CodeBinaryOperatorExpression
{
Left = new CodeVariableReferenceExpression("index"),
Operator = CodeBinaryOperatorType.LessThan,
Right = new CodePropertyReferenceExpression
{
PropertyName = "Length",
TargetObject = array
}
},
IncrementStatement = new CodeAssignStatement
{
Left = new CodeVariableReferenceExpression("index"),
Right = new CodeBinaryOperatorExpression
{
Left = new CodeVariableReferenceExpression("index"),
Operator = CodeBinaryOperatorType.Add,
Right = new CodePrimitiveExpression(1)
}
}
};
returnValue.Statements.AddRange(statements);
return returnValue;
}
protected override void GenerateIterationStatement(System.CodeDom.CodeIterationStatement e)
{
throw new Exception("The method or operation is not implemented.");
}
protected override void GenerateIterationStatement(CodeIterationStatement e)
{
Output.WriteLine("[CodeIterationStatement: {0}]", e.ToString());
}
public override object VisitForeachStatement(ForeachStatement foreachStatement, object data)
{
// RG:
// foreach (T t in x)
// {
// stmts;
// }
//
// Emulate with
//
// for (System.Collections.IEnumerator _it = x.GetEnumerator(); _it.MoveNext(); )
// {
// T t = ((T)_it.Current);
//
// stmts;
// }
foreachId++;
string name = "_it" + foreachId.ToString();
CodeIterationStatement _for1 = new CodeIterationStatement();
breakableStack.Push(new Breakable());
// init
CodeVariableDeclarationStatement _decl2 = new CodeVariableDeclarationStatement();
CodeMethodInvokeExpression _invoke1 = new CodeMethodInvokeExpression();
CodeMethodReferenceExpression _GetEnumerator_method1 = new CodeMethodReferenceExpression();
_GetEnumerator_method1.MethodName = "GetEnumerator";
//CodeCastExpression _cast1 = new CodeCastExpression();
//codeStack.Push(NullStmtCollection);
//_cast1.Expression = (CodeExpression)foreachStatement.Expression.AcceptVisitor(this, data);
//codeStack.Pop();
//CodeTypeReference _IEnumerable_type1 = new CodeTypeReference("System.Collections.IEnumerable");
//_cast1.TargetType = _IEnumerable_type1;
//_GetEnumerator_method1.TargetObject = _cast1;
codeStack.Push(NullStmtCollection);
_GetEnumerator_method1.TargetObject = (CodeExpression)foreachStatement.Expression.AcceptVisitor(this, data);
codeStack.Pop();
_invoke1.Method = _GetEnumerator_method1;
_decl2.InitExpression = _invoke1;
_decl2.Name = name;
CodeTypeReference _IEnumerator_type1 = new CodeTypeReference("System.Collections.IEnumerator");
_decl2.Type = _IEnumerator_type1;
_for1.InitStatement = _decl2;
// Condition
CodeMethodInvokeExpression _invoke2 = new CodeMethodInvokeExpression();
CodeMethodReferenceExpression _MoveNext_method1 = new CodeMethodReferenceExpression();
_MoveNext_method1.MethodName = "MoveNext";
CodeVariableReferenceExpression _arg2 = new CodeVariableReferenceExpression();
_arg2.VariableName = name;
_MoveNext_method1.TargetObject = _arg2;
_invoke2.Method = _MoveNext_method1;
_for1.TestExpression = _invoke2;
// Empty Increment
_for1.IncrementStatement = new CodeExpressionStatement(new CodeSnippetExpression());
// T t = ((T)_it.Current);
CodeVariableDeclarationStatement _decl3 = new CodeVariableDeclarationStatement();
CodeCastExpression _cast2 = new CodeCastExpression();
CodePropertyReferenceExpression _prop1 = new CodePropertyReferenceExpression();
_prop1.PropertyName = "Current";
CodeVariableReferenceExpression _arg3 = new CodeVariableReferenceExpression();
_arg3.VariableName = name;
_prop1.TargetObject = _arg3;
_cast2.Expression = _prop1;
CodeTypeReference _System_String_type5 = ConvType(foreachStatement.TypeReference);
_cast2.TargetType = _System_String_type5;
_decl3.InitExpression = _cast2;
_decl3.Name = foreachStatement.VariableName;
CodeTypeReference _System_String_type6 = ConvType(foreachStatement.TypeReference);
_decl3.Type = _System_String_type6;
_for1.Statements.Add(_decl3);
_for1.Statements.Add(new CodeSnippetStatement());
codeStack.Push(_for1.Statements);
foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
codeStack.Pop();
Breakable breakable = breakableStack.Pop();
if (breakable.IsContinue)
{
_for1.Statements.Add(new CodeSnippetStatement());
_for1.Statements.Add(new CodeLabeledStatement("continue" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
}
AddStmt(_for1);
if (breakable.IsBreak)
{
AddStmt(new CodeLabeledStatement("break" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
}
return _for1;
}
private static void GenerateProperties(Type t, CodeTypeDeclaration codeType)
{
foreach (PropertyInfo property in t.GetProperties())
{
if (OmittedProperties.ContainsKey(t.FullName) && OmittedProperties[t.FullName].Contains(property.Name))
{
continue;
}
if (property.CustomAttributes.Any(x => x.AttributeType.FullName.Contains("Obsolete")))
{
continue;
}
string propertyType = GetPropertyType(property.PropertyType);
bool isGenericCollection = property.PropertyType.IsGenericType &&
(property.PropertyType.GetGenericTypeDefinition() == typeof(IList<>) || property.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>) ||
property.PropertyType.GetGenericTypeDefinition() == typeof(IReadOnlyList<>));
CodeFieldReferenceExpression wrappedObject = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), OmObject);
CodePropertyReferenceExpression wrappedObjectProperty = new CodePropertyReferenceExpression(wrappedObject, property.Name);
CodeFieldReferenceExpression fieldReference = null;
if (isGenericCollection || OMtoPSClassMappings.ContainsKey(property.PropertyType.FullName))
{
// Add a backing field for the property with the same name but using camel case.
string fieldName = string.Format("{0}{1}", property.Name.ToLower()[0], property.Name.Substring(1, property.Name.Length - 1));
CodeMemberField backingField = new CodeMemberField();
backingField.Attributes = MemberAttributes.Private;
backingField.Name = fieldName;
backingField.Type = new CodeTypeReference(propertyType);
codeType.Members.Add(backingField);
fieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName);
}
CodeMemberProperty codeProperty = new CodeMemberProperty();
codeProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
codeProperty.Name = property.Name;
codeProperty.Type = new CodeTypeReference(propertyType);
// For properties with a backing field, the field will not be initialized in the constructor in order to avoid
// hitting a run time access constraint from the OM. Instead, the field is initialized on the first access of
// the property.
if (isGenericCollection)
{
// Collections are not kept in sync with the wrapped OM object. Cmdlets will need to sync them before sending
// a request to the server.
Type argType = property.PropertyType.GetGenericArguments()[0];
string wrapperArgType = argType.FullName.StartsWith("System") ? argType.FullName : OMtoPSClassMappings[argType.FullName];
string wrapperListType = string.Format("List<{0}>", wrapperArgType);
if (property.GetMethod != null && property.GetMethod.IsPublic)
{
codeProperty.HasGet = true;
// Build a list of wrapper objects
const string listVariableName = "list";
CodeVariableDeclarationStatement listDeclaration = new CodeVariableDeclarationStatement(wrapperListType, listVariableName);
CodeVariableReferenceExpression listReference = new CodeVariableReferenceExpression(listVariableName);
CodeAssignStatement initializeList = new CodeAssignStatement(listReference, new CodeObjectCreateExpression(wrapperListType));
// CodeDom doesn't support foreach loops very well, so instead explicitly get the enumerator and loop on MoveNext() calls
const string enumeratorVariableName = "enumerator";
CodeVariableDeclarationStatement enumeratorDeclaration = new CodeVariableDeclarationStatement(string.Format("IEnumerator<{0}>", argType.FullName), enumeratorVariableName);
CodeVariableReferenceExpression enumeratorReference = new CodeVariableReferenceExpression(enumeratorVariableName);
CodeAssignStatement initializeEnumerator = new CodeAssignStatement(enumeratorReference, new CodeMethodInvokeExpression(wrappedObjectProperty, "GetEnumerator"));
CodeIterationStatement loopStatement = new CodeIterationStatement();
loopStatement.TestExpression = new CodeMethodInvokeExpression(enumeratorReference, "MoveNext");
loopStatement.IncrementStatement = new CodeSnippetStatement(string.Empty);
loopStatement.InitStatement = new CodeSnippetStatement(string.Empty);
CodePropertyReferenceExpression enumeratorCurrent = new CodePropertyReferenceExpression(enumeratorReference, "Current");
// Fill the list by individually wrapping each item in the loop
if (wrapperArgType.Contains("System"))
{
CodeMethodInvokeExpression addToList = new CodeMethodInvokeExpression(listReference, "Add", enumeratorCurrent);
loopStatement.Statements.Add(addToList);
}
else
{
CodeObjectCreateExpression createListItem = new CodeObjectCreateExpression(wrapperArgType, enumeratorCurrent);
CodeMethodInvokeExpression addToList = new CodeMethodInvokeExpression(listReference, "Add", createListItem);
loopStatement.Statements.Add(addToList);
}
// Initialize the backing field with the built list on first access of the property
CodeAssignStatement assignStatement;
if (property.PropertyType.GetGenericTypeDefinition() == typeof(IReadOnlyList<>))
{
CodeMethodInvokeExpression asReadOnlyList = new CodeMethodInvokeExpression(listReference, "AsReadOnly");
assignStatement = new CodeAssignStatement(fieldReference, asReadOnlyList);
}
else
{
assignStatement = new CodeAssignStatement(fieldReference, listReference);
}
CodePrimitiveExpression nullExpression = new CodePrimitiveExpression(null);
CodeBinaryOperatorExpression fieldNullCheck = new CodeBinaryOperatorExpression(fieldReference, CodeBinaryOperatorType.IdentityEquality, nullExpression);
CodeBinaryOperatorExpression wrappedPropertyNullCheck = new CodeBinaryOperatorExpression(wrappedObjectProperty, CodeBinaryOperatorType.IdentityInequality, nullExpression);
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(fieldNullCheck, CodeBinaryOperatorType.BooleanAnd, wrappedPropertyNullCheck);
CodeConditionStatement ifBlock = new CodeConditionStatement(condition, listDeclaration, initializeList, enumeratorDeclaration, initializeEnumerator, loopStatement, assignStatement);
codeProperty.GetStatements.Add(ifBlock);
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
}
if (property.SetMethod != null && property.SetMethod.IsPublic)
{
// Call the "set" on the OM object to ensure that constraints are enforced.
codeProperty.HasSet = true;
CodePropertySetValueReferenceExpression valueReference = new CodePropertySetValueReferenceExpression();
CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(valueReference, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
CodeAssignStatement nullAssignment = new CodeAssignStatement(wrappedObjectProperty, new CodePrimitiveExpression(null));
CodeAssignStatement nonNullAssignment = new CodeAssignStatement(wrappedObjectProperty, new CodeObjectCreateExpression(string.Format("List<{0}>", argType.FullName)));
CodeConditionStatement ifBlock = new CodeConditionStatement(nullCheck, new CodeStatement[] { nullAssignment }, new CodeStatement[] { nonNullAssignment });
codeProperty.SetStatements.Add(ifBlock);
codeProperty.SetStatements.Add(new CodeAssignStatement(fieldReference, valueReference));
}
}
else if (OMtoPSClassMappings.ContainsKey(property.PropertyType.FullName))
{
if (property.GetMethod != null && property.GetMethod.IsPublic)
{
codeProperty.HasGet = true;
CodeObjectCreateExpression createFieldObject = new CodeObjectCreateExpression(OMtoPSClassMappings[property.PropertyType.FullName], wrappedObjectProperty);
CodeAssignStatement assignStatement = new CodeAssignStatement(fieldReference, createFieldObject);
CodePrimitiveExpression nullExpression = new CodePrimitiveExpression(null);
CodeBinaryOperatorExpression fieldNullCheck = new CodeBinaryOperatorExpression(fieldReference, CodeBinaryOperatorType.IdentityEquality, nullExpression);
CodeBinaryOperatorExpression wrappedPropertyNullCheck = new CodeBinaryOperatorExpression(wrappedObjectProperty, CodeBinaryOperatorType.IdentityInequality, nullExpression);
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(fieldNullCheck, CodeBinaryOperatorType.BooleanAnd, wrappedPropertyNullCheck);
CodeConditionStatement ifBlock = new CodeConditionStatement(condition, assignStatement);
codeProperty.GetStatements.Add(ifBlock);
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
}
if (property.SetMethod != null && property.SetMethod.IsPublic)
{
codeProperty.HasSet = true;
CodePropertySetValueReferenceExpression valueReference = new CodePropertySetValueReferenceExpression();
CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(valueReference, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
CodeAssignStatement nullAssignment = new CodeAssignStatement(wrappedObjectProperty, new CodePrimitiveExpression(null));
CodePropertyReferenceExpression valueProperty = new CodePropertyReferenceExpression(valueReference, OmObject);
CodeAssignStatement nonNullAssignment = new CodeAssignStatement(wrappedObjectProperty, valueProperty);
CodeConditionStatement ifBlock = new CodeConditionStatement(nullCheck, new CodeStatement[] { nullAssignment }, new CodeStatement[] { nonNullAssignment });
codeProperty.SetStatements.Add(ifBlock);
codeProperty.SetStatements.Add(new CodeAssignStatement(fieldReference, valueReference));
}
}
else
{
// By default, just pass through to the wrapped OM object's property.
if (property.GetMethod != null && property.GetMethod.IsPublic)
{
codeProperty.HasGet = true;
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(wrappedObjectProperty));
}
if (property.SetMethod != null && property.SetMethod.IsPublic)
{
codeProperty.HasSet = true;
codeProperty.SetStatements.Add(new CodeAssignStatement(wrappedObjectProperty, new CodePropertySetValueReferenceExpression()));
}
}
codeType.Members.Add(codeProperty);
}
}
protected abstract void GenerateIterationStatement (CodeIterationStatement s);
public override object Visit(ForStatement forStatement, object data)
{
CodeIterationStatement forLoop = new CodeIterationStatement();
if (forStatement.Initializers != null)
{
if (forStatement.Initializers.Count > 1)
{
throw new NotSupportedException("CodeDom does not support Multiple For-Loop Initializer Statements");
}
foreach (object o in forStatement.Initializers)
{
if (o is Expression)
{
forLoop.InitStatement = new CodeExpressionStatement((CodeExpression)((Expression)o).AcceptVisitor(this,data));
}
if (o is Statement)
{
codeStack.Push(NullStmtCollection);
forLoop.InitStatement = (CodeStatement)((Statement)o).AcceptVisitor(this, data);
codeStack.Pop();
}
}
}
if (forStatement.Condition == null)
{
forLoop.TestExpression = new CodePrimitiveExpression(true);
}
else
{
forLoop.TestExpression = (CodeExpression)forStatement.Condition.AcceptVisitor(this, data);
}
codeStack.Push(forLoop.Statements);
forStatement.EmbeddedStatement.AcceptVisitor(this, data);
codeStack.Pop();
if (forStatement.Iterator != null)
{
if (forStatement.Initializers.Count > 1)
{
throw new NotSupportedException("CodeDom does not support Multiple For-Loop Iterator Statements");
}
foreach (Statement stmt in forStatement.Iterator)
{
forLoop.IncrementStatement = (CodeStatement)stmt.AcceptVisitor(this, data);
}
}
AddStmt(forLoop);
return forLoop;
}
protected override void GenerateIterationStatement (CodeIterationStatement statement)
{
TextWriter output = Output;
GenerateStatement (statement.InitStatement);
output.Write ("Do While ");
GenerateExpression (statement.TestExpression);
output.WriteLine ();
Indent++;
GenerateStatements (statement.Statements);
GenerateStatement (statement.IncrementStatement);
Indent--;
output.WriteLine ("Loop");
}
