private static NRefactory.ConstructorDeclaration FiltertConstructorStatements(NRefactory.ConstructorDeclaration constructorDeclaration, Type baseType) {
var block = new NRefactory.BlockStatement();
foreach (var statement in constructorDeclaration.Body.Statements) {
var expression = statement as NRefactory.ExpressionStatement;
if (expression != null) {
if (expression.Expression is NRefactory.AssignmentExpression) {
continue;
}
var invocation = expression.Expression as NRefactory.InvocationExpression;
block.Add(statement.Clone());
if (invocation != null && invocation.HasAnnotationOf<Cecil.MethodReference>()) {
var methodReference = invocation.Annotation<Cecil.MethodReference>();
if (methodReference.Name.Equals(".ctor") && methodReference.DeclaringType.GetActualType().Equals(baseType)) {
block.AddReturnStatement(new NRefactory.ThisReferenceExpression());
constructorDeclaration.Body = block;
break;
}
}
}
else {
block.Add(statement.Clone());
}
}
return constructorDeclaration;
}
protected internal Index(NRefactory.IndexerExpression indexerExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
bool isAssignment = false;
PropertyReference propertyReference = null;
_indexerExpression = indexerExpression;
isAssignment = IsAssignment();
Target = indexerExpression.Target.AcceptVisitor(Visitor, ParentScope);
TryGetArguments();
if (indexerExpression.HasAnnotationOf<PropertyReference>(out propertyReference)) {
var propertyInfo = Target.Type.GetProperty(propertyReference.Name);
InternalType = propertyInfo.PropertyType;
_indexer = propertyInfo;
}
else {
_isArrayIndex = true;
var targetType = Target.Type;
if (targetType.HasElementType) {
targetType = Target.Type.GetElementType();
}
InternalType = targetType;
_methodCall = _isAssignment ? Expression.ArrayAccess : (Func<Expression, IEnumerable<Expression>, Expression>)Expression.ArrayAccess;
}
}
protected internal ArrayCreation(NRefactory.ArrayCreateExpression arrayCreateExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
_arrayCreateExpression = arrayCreateExpression;
_isJaggeedArray = IsJaggedArray();
_isVector = IsVector();
InternalType = GetArrayType();
if (InternalType.GetArrayRank() == 1 && !_isJaggeedArray) {
if (TryGetOneDimensionalArrayBounds()) {
BuildEmptyOneDimensionalArray();
}
else {
BuildOneDimensionalArray();
}
}
else {
if (TryGetBounds()) {
BuildEmptyMultiDimensionalArray();
}
else {
BuildMultiDimensionalArrayAccess();
}
}
}
protected internal Switch(NRefactory.SwitchStatement switchStatement, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
_switchStatement = switchStatement;
SwitchValue = switchStatement.Expression.AcceptVisitor(Visitor, scope);
BuildSwitchCases();
InternalType = TypeSystem.Void;
}
protected internal New(NRefactory.ObjectCreateExpression objectCreation, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
_objectCreation = objectCreation;
if (!objectCreation.Type.IsNull) {
InternalType = objectCreation.Type.AcceptVisitor(Visitor, ParentScope).Type;
if (objectCreation.Initializer != null) {
if (objectCreation.Arguments.Count == 2) {
Expression expression;
NRefactory.Expression @this = objectCreation.Arguments.First();
NRefactory.Expression func = objectCreation.Arguments.Last();
if (TryHandleAnonymousMethod(@this, func as NRefactory.InvocationExpression, out expression)) {
Expression = expression;
return;
}
}
if (objectCreation.Initializer != NRefactory.ArrayInitializerExpression.Null) {
Expression = objectCreation.Initializer.AcceptVisitor(Visitor, ParentScope);
return;
}
}
Expression = BuildConstructor();
}
else {
Expression = HandleAnonymousType();
}
}
protected internal Direction(NRefactory.DirectionExpression directionExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
_directionExpression = directionExpression;
IdentifierParameter = directionExpression.Expression.AcceptVisitor(Visitor, scope) as Identifier;
_outParameter = ParentScope.Find(IdentifierParameter.Name);
InternalType = IdentifierParameter.Type;
}
protected internal CaseLabel(NRefactory.CaseLabel caseLabel, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
var expression = caseLabel.Expression;
_caseLabel = caseLabel;
DefaultValue = expression.AcceptVisitor(Visitor, ParentScope);
InternalType = DefaultValue.Type;
}
protected internal Identifier(NRefactory.IdentifierExpression identifierExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
_identifierExpression = identifierExpression;
Expression = scope.Find(_identifierExpression.Identifier);
InternalType = Expression.Type;
Name = _identifierExpression.Identifier;
}
protected internal Invocation(NRefactory.InvocationExpression invocationExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
var methodReference = invocationExpression.Annotation<Mono.Cecil.MethodReference>();
_invocationExpression = invocationExpression;
if (methodReference != null) {
MethodInfo methodInfo = null;
Member = methodInfo = methodReference.GetActualMethod<MethodInfo>();
if (IsInitializeArray(methodInfo)) {
var first = _invocationExpression.Arguments.First().AcceptVisitor(Visitor, ParentScope);
var invocation = _invocationExpression.Arguments.Last() as NRefactory.InvocationExpression;
var second = invocation.Arguments.First();
var memberReference = invocationExpression.Target as NRefactory.MemberReferenceExpression;
var target = memberReference.Target as NRefactory.TypeReferenceExpression;
var type = target.Type.GetActualType();
var parameters = methodReference.Parameters;
return;
}
}
BuildInvocation();
}
public MappedInvocation(NRefactory.ConstructorDeclaration ctor, MethodDefinition baseCtor) {
var parameterTypes = new List<Type>();
var ctorType = ctor.GetActualType();
_parameters = ctor.Parameters
.Select((p, i) => {
return new Parameter(p.Name, p.GetActualType(), i);
})
.ToArray();
_parameterDeclarations = ctor.Parameters.ToArray();
_visitor.VisitConstructorDeclaration(ctor, null);
_outParameters = new List<Parameter>();
parameterTypes = new List<Type>();
_parameters.ForEach((p, i) => {
var type = p.Type;
if (_visitor.Contains(p.Name)) {
if (!type.IsByRef) {
type = type.MakeByRefType();
p = new Parameter(p.Name, type, p.Location);
}
_outParameters.Add(p);
}
parameterTypes.Add(type);
});
VerifyUniqueness(ctorType, parameterTypes);
Parameters = parameterTypes.ToArray();
}
protected internal NamedExpression(NRefactory.NamedExpression namedExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
Name = namedExpression.Identifier;
_namedExpression = namedExpression;
Expression = _namedExpression.Expression.AcceptVisitor(Visitor, ParentScope);
InternalType = Expression.Type;
}
protected internal Init(NRefactory.VariableInitializer variableInitializer, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
NRefactory.Expression initializer = null;
_variableInitializer = variableInitializer;
initializer = variableInitializer.Initializer;
}
public static ConstructorBlock ConstructorBlock(NRefactory.BlockStatement blockStatement,
ParameterExpression contextParameter,
IScope scope,
INRefcatoryExpressionVisitor visitor,
IEnumerable<ParameterExpression> parameters = null,
IEnumerable<ParameterExpression> baseConstructorParameters = null) {
return new ConstructorBlock(blockStatement, contextParameter, parameters: parameters, scope: scope, visitor: visitor, baseConstructorParameters: baseConstructorParameters);
}
protected internal Block(NRefactory.BlockStatement blockStatement, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable<ParameterExpression> parameters = null)
: base(scope, visitor) {
_blockStatement = blockStatement;
InternalType = ResolveType(blockStatement);
Parameters = parameters;
BuildExpressions();
}
protected internal AnonymousType(NRefactory.AnonymousTypeCreateExpression anonymousTypeCreateExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
var typeInformation = anonymousTypeCreateExpression.Annotation<TypeInformation>();
_anonymousTypeCreateExpression = anonymousTypeCreateExpression;
_initializers = _anonymousTypeCreateExpression.Initializers.Select(i => i.AcceptVisitor(Visitor, ParentScope));
InternalType = typeInformation.InferredType.GetActualType();
}
protected internal Base(NRefactory.BaseReferenceExpression baseReferenceExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
var memberReference = baseReferenceExpression.Parent.Annotation<Mono.Cecil.MemberReference>();
_baseReferenceExpression = baseReferenceExpression;
Context = RootScope.Context.Expression;
InternalType = memberReference != null ? memberReference.DeclaringType.GetActualType() : Context.Type;
}
public MethodBlock(NRefactory.BlockStatement blockStatement, IScope scope, INRefcatoryExpressionVisitor visitor, IEnumerable<ParameterExpression> parameters = null)
: base(blockStatement, parameters: parameters, scope: scope, visitor: visitor) {
var registry = RootScope.BranchingRegistry;
if (registry.HasReturnLabel) {
AddReturnLabelExpression();
}
}
internal IEnumerable<Parameter> GetOutParameters(NRefactory.ConstructorDeclaration ctor) {
var mapped = _mappedInvocations.FirstOrDefault(m => m.CanMapTo(ctor));
if (mapped != null) {
return mapped.OutParameters;
}
return null;
}
private Expression ReduceEvent(NRefactory.AssignmentExpression assignmentExpression) {
ExpressionType expressionType;
if (!Enum.TryParse<ExpressionType>(assignmentExpression.Operator.ToString(), out expressionType)) {
throw new InvalidOperationException("Event registration must have an add/subtract operator");
}
return AstExpression.Event(Expression, Member as EventInfo, expressionType, ParentScope, Visitor);
}
private static NRefactory.ConstructorDeclaration ResolveConstructor(NRefactory.ConstructorDeclaration constructorDeclaration, Type baseType, ILGenerator iLGenerator, List<Cil.Instruction> instructions) {
ConstructorEmitterVisitor constructorEmitter = null;
constructorDeclaration = FiltertConstructorStatements(constructorDeclaration, baseType);
constructorEmitter = new ConstructorEmitterVisitor(constructorDeclaration, new InstructionsIndexer(instructions));
constructorDeclaration.AcceptVisitor(constructorEmitter, iLGenerator);
return constructorDeclaration;
}
public override Type ResolveType(NRefactory.BlockStatement blockStatement) {
var methodDeclaration = blockStatement.Parent as NRefactory.MethodDeclaration;
if (methodDeclaration != null) {
return methodDeclaration.GetReturnType();
}
return null;
}
public static Method Method(NRefactory.MethodDeclaration methodDeclaration, object context, INRefcatoryExpressionVisitor visitor, IScope scope = null) {
Method methodBlock = null;
if (!methodDeclaration.IsCompilerGeneratorEnumerator(ref methodBlock)) {
methodBlock = new MethodDeclaration(methodDeclaration, context, scope, visitor);
}
return methodBlock;
}
protected internal Binary(NRefactory.BinaryOperatorExpression binaryOperatorExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
_binaryOperatorExpression = binaryOperatorExpression;
Left = binaryOperatorExpression.Left.AcceptVisitor(Visitor, ParentScope);
Right = binaryOperatorExpression.Right.AcceptVisitor(Visitor, ParentScope);
_binaryOperationType = GetBinaryOperator(binaryOperatorExpression.Operator);
_promotionDecisions = BinaryNumericPromotionDecision.Decide(Left.Type, Right.Type);
InternalType = binaryOperatorExpression.GetBinaryOperationType(_promotionDecisions, Left.Type);
}
protected internal Return(NRefactory.ReturnStatement returnStatement, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
_returnStatement = returnStatement;
Value = returnStatement.Expression.AcceptVisitor(Visitor, ParentScope);
if (Value != null) {
InternalType = Value.Type;
Target = RootScope.BranchingRegistry.RegisterReturnStatementLabel(InternalType);
}
}
protected internal MethodOf(NRefactory.InvocationExpression invocationExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
var memberReference = invocationExpression.Arguments.First() as NRefactory.MemberReferenceExpression;
var loadMethodTokenInvocation = memberReference.Target as NRefactory.InvocationExpression;
var methodReference = loadMethodTokenInvocation.Arguments.First().Annotation<MethodReference>();
_invocationExpression = invocationExpression;
Member = methodReference.GetActualMethod<MethodInfo>();
InternalType = typeof(RuntimeMethodHandle);
}
internal Func<Expression, Expression, BinaryExpression> this[NRefactory.BinaryOperatorType @operator, bool isChecked] {
get {
CheckedUncheckedEntry entry;
Func<Expression, Expression, BinaryExpression> func = null;
if (_methods.TryGetValue(@operator, out entry)) {
func = entry[isChecked];
}
return func;
}
}
protected internal Assign(NRefactory.AssignmentExpression assignmentExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
AstExpression left = null;
_assignment = assignmentExpression;
Right = _rightExpression = assignmentExpression.Right.AcceptVisitor(Visitor, ParentScope);
left = assignmentExpression.Left.AcceptVisitor(Visitor, ParentScope);
Left = left.Reduce();
_isInvocable = IsInvocable(Left, out _invokedType);
InternalType = left.Type;
}
public bool CanMapTo(NRefactory.ConstructorDeclaration ctor) {
if (ctor.Parameters.Count != _parameterDeclarations.Length) {
return false;
}
return ctor.Parameters
.All((p, i) => {
var parameter = _parameterDeclarations[i];
return p.Name.Equals(parameter.Name) &&
p.GetActualType().Equals(parameter.GetActualType());
});
}
public ConstructorBlock(NRefactory.BlockStatement blockStatement,
ParameterExpression contextParameter,
IScope scope,
INRefcatoryExpressionVisitor visitor,
IEnumerable<ParameterExpression> parameters,
IEnumerable<ParameterExpression> baseConstructorParameters)
: base(blockStatement, parameters: parameters, scope: scope, visitor: visitor) {
_baseConstructorParameters = baseConstructorParameters;
AddNewContextCreationExpression(contextParameter);
InternalType = contextParameter.Type;
AddReturnLabelExpression();
}
protected internal ArrayInitializer(NRefactory.ArrayInitializerExpression arrayInitializerExpression, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
MethodReference methodReference;
_arrayInitializerExpression = arrayInitializerExpression;
if (_arrayInitializerExpression.Parent.HasAnnotationOf<MethodReference>(out methodReference)) {
_constructor = methodReference.GetActualMethod() as ConstructorInfo;
InternalType = _constructor.DeclaringType;
}
_initializers = arrayInitializerExpression.Elements
.Select(e => e.AcceptVisitor(Visitor, ParentScope))
.ToList();
}
