public IParameter[] GetParameters()
{
if (null == _parameters)
{
_parameters = _typeSystemServices.Map(_property.GetIndexParameters());
}
return(_parameters);
}
private BooClassBuilder SetUpEnumerableClassBuilder(Node sourceNode, Method enclosingMethod, IType generatorItemType,
TypeReplacer replacer)
{
var builder = CodeBuilder.CreateClass(
Context.GetUniqueName(enclosingMethod.Name, "Enumerable"),
TypeMemberModifiers.Internal | TypeMemberModifiers.Final);
if (enclosingMethod.DeclaringType.IsTransient)
{
builder.Modifiers |= TypeMemberModifiers.Transient;
}
builder.LexicalInfo = new LexicalInfo(sourceNode.LexicalInfo);
builder.AddAttribute(CodeBuilder.CreateAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)));
foreach (var gen in enclosingMethod.DeclaringType.GenericParameters.Concat(enclosingMethod.GenericParameters))
{
var replacement = builder.AddGenericParameter(gen.Name);
CopyConstraints(gen, replacement);
replacer.Replace((IType)gen.Entity, (IType)replacement.Entity);
}
generatorItemType = replacer.MapType(generatorItemType);
builder.AddBaseType(
TypeSystemServices.Map(typeof(GenericGenerator <>)).GenericInfo.ConstructType(generatorItemType));
return(builder);
}
void CreateAnonymousGeneratorType()
{
_enumerable = (BooClassBuilder)_generator["GeneratorClassBuilder"];
_enumerator = _collector.CreateSkeletonClass("Enumerator");
_enumerator.AddBaseType(TypeSystemServices.IEnumeratorType);
_enumerator.AddBaseType(TypeSystemServices.Map(typeof(ICloneable)));
_enumeratorField = _enumerator.AddField("____enumerator",
TypeSystemServices.IEnumeratorType);
_current = _enumerator.AddField("____current",
TypeSystemServices.ObjectType);
CreateReset();
CreateCurrent();
CreateMoveNext();
CreateClone();
EnumeratorConstructorMustCallReset();
_collector.AdjustReferences();
_collector.DeclareFieldsAndConstructor(_enumerable);
CreateGetEnumerator();
_enumerable.ClassDefinition.Members.Add(_enumerator.ClassDefinition);
}
private Expression InjectCast(Expression exp)
{
var method = exp.Entity as IMethod;
if (method == null)
{
return(exp);
}
IType castTargetType;
var parameters = method.GetParameters();
if (parameters.Length > 0 || (method.ReturnType != TypeSystemServices.VoidType && method.ReturnType != null))
{
var isFunc = method.ReturnType != null && method.ReturnType != TypeSystemServices.VoidType;
var genericTypeParameters = parameters.Select(p => p.Type).ToList();
if (isFunc)
{
genericTypeParameters.Add(method.ReturnType);
}
castTargetType = new GenericConstructedType(TypeSystemServices.Map(isFunc ? typeof(Func <>) : typeof(Action <>)), genericTypeParameters.ToArray());
}
else
{
castTargetType = TypeSystemServices.Map(typeof(Action));
}
return(CodeBuilder.CreateCast(castTargetType, exp));
}
IType FindBestEnumeratorType()
{
//type is already an IEnumerator, use it
if (IsAssignableFrom(TypeSystemServices.IEnumeratorType, CurrentEnumeratorType))
{
return(CurrentEnumeratorType);
}
IType bestEnumeratorType = null;
_candidates.Clear();
//resolution order:
//1) type contains an applicable GetEnumerator() [whether or not type implements IEnumerator (as C# does)]
CurrentEnumeratorType.Resolve(_candidates, "GetEnumerator", EntityType.Method);
foreach (IEntity candidate in _candidates)
{
IMethod m = (IMethod)candidate;
if (null != m.GenericInfo || 0 != m.GetParameters().Length || !m.IsPublic)
{
continue; //only check public non-generic GetEnumerator with no argument
}
if (!IsAssignableFrom(TypeSystemServices.IEnumeratorGenericType, m.ReturnType) &&
!IsAssignableFrom(TypeSystemServices.IEnumeratorType, m.ReturnType))
{
continue; //GetEnumerator does not return an IEnumerator or IEnumerator[of T]
}
bestEnumeratorType = m.ReturnType;
_bestGetEnumerator = m;
break;
}
//2) type explicitly implements IEnumerable[of T]
if (null == bestEnumeratorType)
{
if (IsAssignableFrom(TypeSystemServices.IEnumerableGenericType, CurrentEnumeratorType))
{
bestEnumeratorType = TypeSystemServices.IEnumeratorGenericType;
_bestGetEnumerator = TypeSystemServices.Map(Types.IEnumerableGeneric.GetMethod("GetEnumerator"));
}
}
//3) type explicitly implements IEnumerable
if (null == bestEnumeratorType)
{
if (IsAssignableFrom(TypeSystemServices.IEnumerableType, CurrentEnumeratorType))
{
bestEnumeratorType = TypeSystemServices.IEnumeratorType;
_bestGetEnumerator = TypeSystemServices.Map(Types.IEnumerable.GetMethod("GetEnumerator"));
}
}
//4) error
if (null == bestEnumeratorType)
{
Errors.Add(CompilerErrorFactory.InvalidIteratorType(_iteratorNode, CurrentEnumeratorType));
}
return(bestEnumeratorType);
}
public override void OnMethodInvocationExpression(MethodInvocationExpression node)
{
if (node.Target.Entity != null && node.Target.Entity == TypeSystemServices.ICallableType.GetMembers().Single(m => m.Name == "Call"))
{
var mreOriginal = (MemberReferenceExpression)node.Target;
var newMethod = TypeSystemServices.Map(typeof(Delegate).GetMethod("DynamicInvoke", BindingFlags.Instance | BindingFlags.Public));
var newTarget = new MemberReferenceExpression(mreOriginal.Target, newMethod.Name);
newTarget.Entity = newMethod;
node.Replace(node.Target, newTarget);
}
else if (node.Target.Entity != null && node.Target.Entity.EntityType == EntityType.Method)
{
var parameters = ((IMethodBase)node.Target.Entity).GetParameters();
var args = node.Arguments.ToArray();
for (int i = 0; i < args.Length && i < parameters.Length; i++)
{
if (args[i].ExpressionType != null && TypeSystemServices.IsCallable(args[i].ExpressionType) && !TypeSystemServices.IsCallable(parameters[i].Type))
{
node.Replace(args[i], InjectCast(args[i]));
}
}
}
base.OnMethodInvocationExpression(node);
}
private void CreateEnumerator()
{
_enumerator = CodeBuilder.CreateClass("$Enumerator");
_enumerator.AddAttribute(CodeBuilder.CreateAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)));
_enumerator.Modifiers |= _enumerable.Modifiers;
_enumerator.LexicalInfo = this.LexicalInfo;
foreach (var param in _genericParams)
{
var replacement = _enumerator.AddGenericParameter(param.Name);
_methodToEnumeratorMapper.Replace((IType)param.Entity, (IType)replacement.Entity);
}
var abstractEnumeratorType =
TypeSystemServices.Map(typeof(GenericGeneratorEnumerator <>)).
GenericInfo.ConstructType(_methodToEnumeratorMapper.MapType(_generatorItemType));
_state = NameResolutionService.ResolveField(abstractEnumeratorType, "_state");
_yield = NameResolutionService.ResolveMethod(abstractEnumeratorType, "Yield");
_yieldDefault = NameResolutionService.ResolveMethod(abstractEnumeratorType, "YieldDefault");
_enumerator.AddBaseType(abstractEnumeratorType);
_enumerator.AddBaseType(TypeSystemServices.IEnumeratorType);
CreateEnumeratorConstructor();
CreateMoveNext();
_enumerable.ClassDefinition.Members.Add(_enumerator.ClassDefinition);
}
protected override void InitializeMemberCache()
{
base.InitializeMemberCache();
getParam = TypeSystemServices.Map(typeof(BrailBase).GetMethod("GetParameter"));
tryGetParam = TypeSystemServices.Map(typeof(BrailBase).GetMethod("TryGetParameter"));
wrapNullValue = TypeSystemServices.Map(typeof(BrailBase).GetMethod("WrapPossilbeNullValue"));
}
/// <summary>
/// Perform the actual expansion of the macro
/// </summary>
/// <param name="macro">The macro.</param>
/// <returns></returns>
protected override Statement DoExpand(MacroStatement macro)
{
if (macro.Arguments.Count != 0)
{
Errors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo, "No arguments allowed for action statement"));
return(null);
}
Method mergeRowsMethod = new Method("MergeRows");
mergeRowsMethod.Modifiers = TypeMemberModifiers.Override;
mergeRowsMethod.Parameters.Add(new ParameterDeclaration("left", new SimpleTypeReference(typeof(Row).FullName)));
mergeRowsMethod.Parameters.Add(new ParameterDeclaration("right", new SimpleTypeReference(typeof(Row).FullName)));
CodeBuilder.DeclareLocal(mergeRowsMethod, "row", TypeSystemServices.Map(typeof(Row)));
mergeRowsMethod.Body.Add(
new BinaryExpression(BinaryOperatorType.Assign,
new ReferenceExpression("row"),
new MethodInvocationExpression(
AstUtil.CreateReferenceExpression(typeof(Row).FullName))
)
);
mergeRowsMethod.Body.Add(macro.Body);
mergeRowsMethod.Body.Add(new ReturnStatement(new ReferenceExpression("row")));
ParentMethods.Add(mergeRowsMethod);
return(null);
}
/// <summary>
/// Gets the member of the specified type with the specified name, assuming there is only one.
/// </summary>
private IEntity GetMember(IType type, string name, EntityType entityType)
{
// For external types we can use GetMethod or GetProperty to optimize things a little
ExternalType external = type as ExternalType;
if (external != null)
{
if (entityType == EntityType.Property)
{
return(TypeSystemServices.Map(
((ExternalType)type).ActualType.GetProperty(name)));
}
else if (entityType == EntityType.Method)
{
return(TypeSystemServices.Map(
((ExternalType)type).ActualType.GetMethod(name)));
}
}
// For constructed types which aren't external we can use the GenericMapping to
// (maybe) optimize things a little
if (type.ConstructedInfo != null)
{
return(((GenericConstructedType)type).GenericMapping.Map(
GetMember(type.ConstructedInfo.GenericDefinition, name, entityType)));
}
// For other cases we just scan through the members collection
return(Array.Find <IEntity>(
type.GetMembers(),
delegate(IEntity e) {
return entityType == e.EntityType && e.Name == name;
}));
}
void Initialize()
{
Type type = typeof(AsyncResult);
_asyncResultType = TypeSystemServices.Map(type);
_asyncResultTypeAsyncDelegateGetter = TypeSystemServices.Map(Methods.GetterOf <AsyncResult, object>(r => r.AsyncDelegate));
_adaptors = new Boo.Lang.List();
}
void Initialize()
{
Type type = typeof(System.Runtime.Remoting.Messaging.AsyncResult);
_asyncResultType = TypeSystemServices.Map(type);
_asyncResultTypeAsyncDelegateGetter = TypeSystemServices.Map(type.GetProperty("AsyncDelegate").GetGetMethod());
_adaptors = new Boo.Lang.List();
}
private void InitializeDelegateMethods()
{
if (null != _delegate_Combine)
{
return;
}
_delegate_Combine = TypeSystemServices.Map(Methods.Of <Delegate, Delegate, Delegate>(Delegate.Combine));
_delegate_Remove = TypeSystemServices.Map(Methods.Of <Delegate, Delegate, Delegate>(Delegate.Remove));
}
public void ImplicitConversionFromNullableToValue()
{
RunInCompilerContextEnvironment(delegate
{
var nullableDouble = TypeSystemServices.Map(typeof(double?));
var doubleType = TypeSystemServices.Map(typeof(double));
var conversionOperator = TypeSystemServices.FindExplicitConversionOperator(nullableDouble, doubleType);
Assert.IsNotNull(conversionOperator);
});
}
void CreateReset()
{
BooMethodBuilder method = _enumerator.AddVirtualMethod("Reset", TypeSystemServices.VoidType);
method.Body.Add(
CodeBuilder.CreateAssignment(
CodeBuilder.CreateReference((InternalField)_enumeratorField.Entity),
CodeBuilder.CreateMethodInvocation(_generator.Iterator,
TypeSystemServices.Map(Types.IEnumerable.GetMethod("GetEnumerator")))));
}
public void TypeOfFirstArgumentRule()
{
RunInCompilerContextEnvironment(() =>
{
var type = TypeSystemServices.Map(typeof(string));
var method = TypeSystemServices.Map(Methods.Of <object, object>(Instantiate));
var invocation = CodeBuilder.CreateMethodInvocation(method, StringLiteral());
Assert.AreSame(type, Subject.ApplyTo(invocation, method));
});
}
public void TypeReferencedBySecondArgumentRule()
{
RunInCompilerContextEnvironment(() =>
{
var type = TypeSystemServices.Map(typeof(string));
var method = TypeSystemServices.Map(Methods.Of <string, Type, object>(Load));
var invocation = CodeBuilder.CreateMethodInvocation(method, StringLiteral(), TypeReference(type));
Assert.AreSame(type, Subject.ApplyTo(invocation, method));
});
}
void CreateAnonymousGeneratorType()
{
_enumerable = (BooClassBuilder)_generator["GeneratorClassBuilder"];
_sourceItemType = TypeSystemServices.ObjectType;
_sourceEnumeratorType = TypeSystemServices.IEnumeratorType;
_sourceEnumerableType = TypeSystemServices.IEnumerableType;
_resultItemType = (IType)_generator["GeneratorItemType"];
_resultEnumeratorType = TypeSystemServices.IEnumeratorType;
//_enumerator = _collector.CreateSkeletonClass(_enumerable.ClassDefinition.Name + "Enumerator");
_enumerator = _collector.CreateSkeletonClass("Enumerator");
#if NET_2_0
// If source item type isn't object, use a generic enumerator for the source type
_sourceItemType = TypeSystemServices.GetGenericEnumerableItemType(_generator.Iterator.ExpressionType);
if (_sourceItemType != null && _sourceItemType != TypeSystemServices.ObjectType)
{
_sourceEnumerableType = TypeSystemServices.IEnumerableGenericType.GenericTypeDefinitionInfo.MakeGenericType(_sourceItemType);
_sourceEnumeratorType = TypeSystemServices.IEnumeratorGenericType.GenericTypeDefinitionInfo.MakeGenericType(_sourceItemType);
}
else
{
_sourceItemType = TypeSystemServices.ObjectType;
}
// Expose a generic enumerator
_resultEnumeratorType = TypeSystemServices.IEnumeratorGenericType.GenericTypeDefinitionInfo.MakeGenericType(_resultItemType);
#endif
_enumerator.AddBaseType(_resultEnumeratorType);
_enumerator.AddBaseType(TypeSystemServices.Map(typeof(ICloneable)));
_enumerator.AddBaseType(TypeSystemServices.Map(typeof(IDisposable)));
_enumeratorField = _enumerator.AddField("____enumerator", _sourceEnumeratorType);
_current = _enumerator.AddField("____current", _resultItemType);
CreateReset();
CreateCurrent();
CreateMoveNext();
CreateClone();
CreateDispose();
EnumeratorConstructorMustCallReset();
_collector.AdjustReferences();
_collector.DeclareFieldsAndConstructor(_enumerable);
CreateGetEnumerator();
_enumerable.ClassDefinition.Members.Add(_enumerator.ClassDefinition);
//TypeSystemServices.AddCompilerGeneratedType(_enumerator.ClassDefinition);
}
private void CreateDispose()
{
BooMethodBuilder dispose = _enumerator.AddVirtualMethod("Dispose", TypeSystemServices.VoidType);
if (TypeSystemServices.Map(typeof(IDisposable)).IsAssignableFrom(_sourceEnumeratorType))
{
dispose.Body.Add(CodeBuilder.CreateMethodInvocation(
CodeBuilder.CreateReference(_enumeratorField),
typeof(IDisposable).GetMethod("Dispose")));
}
}
protected override void InitializeDuckTypingServices()
{
base.InitializeDuckTypingServices();
var duckTypingServices = TypeSystemServices.Map(GetType());
RuntimeServices_Invoke = GetResolvedMethod(duckTypingServices, "Invoke");
RuntimeServices_SetProperty = GetResolvedMethod(duckTypingServices, "SetProperty");
RuntimeServices_GetProperty = GetResolvedMethod(duckTypingServices, "GetProperty");
RuntimeServices_SetSlice = GetResolvedMethod(duckTypingServices, "SetSlice");
RuntimeServices_GetSlice = GetResolvedMethod(duckTypingServices, "GetSlice");
}
public override void Initialize(CompilerContext context)
{
base.Initialize(context);
_runtimeServices = TypeSystemServices.Map(typeof(Boo.Lang.Runtime.RuntimeServices));
RuntimeServices_Invoke = ResolveMethod(_runtimeServices, "Invoke");
RuntimeServices_InvokeCallable = ResolveMethod(_runtimeServices, "InvokeCallable");
RuntimeServices_InvokeBinaryOperator = ResolveMethod(_runtimeServices, "InvokeBinaryOperator");
RuntimeServices_InvokeUnaryOperator = ResolveMethod(_runtimeServices, "InvokeUnaryOperator");
RuntimeServices_SetProperty = ResolveMethod(_runtimeServices, "SetProperty");
RuntimeServices_GetProperty = ResolveMethod(_runtimeServices, "GetProperty");
RuntimeServices_GetSlice = ResolveMethod(_runtimeServices, "GetSlice");
}
IMethod GetMemberwiseCloneMethod()
{
#if DNXCORE50
return(TypeSystemServices.Map(
typeof(object).GetTypeInfo().GetMethod("MemberwiseClone",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)));
#else
return(TypeSystemServices.Map(
typeof(object).GetMethod("MemberwiseClone",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)));
#endif
}
public void DeclaringTypeOfConstructedMethod()
{
RunInCompilerContextEnvironment(() =>
{
var genericType = TypeSystemServices.Map(typeof(IEnumerable <>));
var internalType = BuildInternalClass("", "Bar").Entity;
var constructedType = genericType.GenericInfo.ConstructType(internalType);
var firstMethod = constructedType.GetMembers().OfType <IMethod>().First();
Assert.AreSame(constructedType, firstMethod.DeclaringType);
});
}
void InitializeAsyncResultType()
{
if (_asyncResultType != null)
{
return;
}
var type = typeof(AsyncResult);
_asyncResultType = TypeSystemServices.Map(type);
_asyncResultTypeAsyncDelegateGetter = TypeSystemServices.Map(Methods.GetterOf <AsyncResult, object>(r => r.AsyncDelegate));
}
void InitializeDelegateMethods()
{
if (null != _delegate_Combine)
{
return;
}
Type delegateType = Types.Delegate;
Type[] delegates = new Type[] { delegateType, delegateType };
_delegate_Combine = TypeSystemServices.Map(delegateType.GetMethod("Combine", delegates));
_delegate_Remove = TypeSystemServices.Map(delegateType.GetMethod("Remove", delegates));
}
void ExpandComplexArraySlicing(SlicingExpression node)
{
if (node.Indices.Count > 1)
{
MethodInvocationExpression mie = null;
var computeEnd = new ArrayLiteralExpression();
var collapse = new ArrayLiteralExpression();
var ranges = new ArrayLiteralExpression();
for (int i = 0; i < node.Indices.Count; i++)
{
ranges.Items.Add(node.Indices[i].Begin);
if (node.Indices[i].End == null)
{
var end = new BinaryExpression(BinaryOperatorType.Addition, node.Indices[i].Begin, new IntegerLiteralExpression(1));
ranges.Items.Add(end);
BindExpressionType(end, GetExpressionType(node.Indices[i].Begin));
computeEnd.Items.Add(new BoolLiteralExpression(false));
collapse.Items.Add(new BoolLiteralExpression(true));
}
else if (node.Indices[i].End == OmittedExpression.Default)
{
var end = new IntegerLiteralExpression(0);
ranges.Items.Add(end);
BindExpressionType(end, GetExpressionType(node.Indices[i].Begin));
computeEnd.Items.Add(new BoolLiteralExpression(true));
collapse.Items.Add(new BoolLiteralExpression(false));
}
else
{
ranges.Items.Add(node.Indices[i].End);
computeEnd.Items.Add(new BoolLiteralExpression(false));
collapse.Items.Add(new BoolLiteralExpression(false));
}
}
mie = CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetMultiDimensionalRange1, node.Target, ranges);
mie.Arguments.Add(computeEnd);
mie.Arguments.Add(collapse);
BindExpressionType(ranges, TypeSystemServices.Map(typeof(int[])));
BindExpressionType(computeEnd, TypeSystemServices.Map(typeof(bool[])));
BindExpressionType(collapse, TypeSystemServices.Map(typeof(bool[])));
node.ParentNode.Replace(node, mie);
}
else
{
var slice = node.Indices[0];
var mie = IsNullOrOmitted(slice.End)
? CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange1, node.Target, slice.Begin)
: CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange2, node.Target, slice.Begin, slice.End);
node.ParentNode.Replace(node, mie);
}
}
protected override void SetupStateMachine()
{
_stateMachineClass.Modifiers |= _enumerable.Modifiers;
var abstractEnumeratorType =
TypeSystemServices.Map(typeof(GenericGeneratorEnumerator <>)).
GenericInfo.ConstructType(_methodToStateMachineMapper.MapType(_generatorItemType));
_state = NameResolutionService.ResolveField(abstractEnumeratorType, "_state");
_yield = NameResolutionService.ResolveMethod(abstractEnumeratorType, "Yield");
_yieldDefault = NameResolutionService.ResolveMethod(abstractEnumeratorType, "YieldDefault");
_stateMachineClass.AddBaseType(abstractEnumeratorType);
_stateMachineClass.AddBaseType(TypeSystemServices.IEnumeratorType);
}
Method CreateBeginInvokeMethod(ICallableType anonymousType)
{
Method method = CodeBuilder.CreateRuntimeMethod("BeginInvoke", TypeSystemServices.Map(typeof(IAsyncResult)),
anonymousType.GetSignature().Parameters, false);
int delta = method.Parameters.Count;
method.Parameters.Add(
CodeBuilder.CreateParameterDeclaration(delta + 1, "callback", TypeSystemServices.Map(typeof(AsyncCallback))));
method.Parameters.Add(
CodeBuilder.CreateParameterDeclaration(delta + 1, "asyncState", TypeSystemServices.ObjectType));
return(method);
}
override public void OnListLiteralExpression(ListLiteralExpression node)
{
bool generator = AstUtil.IsListGenerator(node);
Visit(node.Items);
if (generator)
{
ReplaceCurrentNode(
CodeBuilder.CreateConstructorInvocation(
TypeSystemServices.Map(List_IEnumerableConstructor),
node.Items[0]));
}
}
public void CreateTypeofExpression()
{
RunInCompilerContextEnvironment(() =>
{
var type = TypeSystemServices.Map(typeof(string));
var e = CodeBuilder.CreateTypeofExpression(type);
Assert.IsNull(e.Entity);
Assert.AreSame(TypeSystemServices.Map(typeof(Type)), e.ExpressionType);
Assert.AreSame(type, e.Type.Entity);
});
}