/*
* Completes the anonymous method processing, if lambda_expr is null, this
* means that we have a Statement instead of an Expression embedded
*/
AnonymousMethodExpression end_anonymous (ParametersBlock anon_block)
{
AnonymousMethodExpression retval;
if (async_block)
anon_block.IsAsync = true;
current_anonymous_method.Block = anon_block;
retval = current_anonymous_method;
async_block = (bool) oob_stack.Pop ();
current_variable = (BlockVariable) oob_stack.Pop ();
current_local_parameters = (ParametersCompiled) oob_stack.Pop ();
current_anonymous_method = (AnonymousMethodExpression) oob_stack.Pop ();
return retval;
}
public override object Visit(Mono.CSharp.AnonymousMethodExpression anonymousMethodExpression)
{
var result = new AnonymousMethodExpression();
var location = LocationsBag.GetLocations(anonymousMethodExpression);
int l = 0;
if (anonymousMethodExpression.IsAsync) {
result.IsAsync = true;
result.AddChild(new CSharpTokenNode(Convert(location [l++]), AnonymousMethodExpression.AsyncModifierRole), AnonymousMethodExpression.AsyncModifierRole);
}
if (location != null) {
result.AddChild(new CSharpTokenNode(Convert(location [l++]), AnonymousMethodExpression.DelegateKeywordRole), AnonymousMethodExpression.DelegateKeywordRole);
if (location.Count > l) {
result.HasParameterList = true;
result.AddChild(new CSharpTokenNode(Convert(location [l++]), Roles.LPar), Roles.LPar);
AddParameter(result, anonymousMethodExpression.Parameters);
result.AddChild(new CSharpTokenNode(Convert(location [l++]), Roles.RPar), Roles.RPar);
}
}
if (anonymousMethodExpression.Block != null)
result.AddChild((BlockStatement)anonymousMethodExpression.Block.Accept(this), Roles.Body);
return result;
}
public override object Visit (Mono.CSharp.AnonymousMethodExpression anonymousMethodExpression)
{
var result = new AnonymousMethodExpression ();
var location = LocationsBag.GetLocations (anonymousMethodExpression);
if (location != null) {
result.AddChild (new CSharpTokenNode (Convert (location[0]), "delegate".Length), AnonymousMethodExpression.Roles.Keyword);
if (location.Count > 1) {
result.HasParameterList = true;
result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AnonymousMethodExpression.Roles.LPar);
AddParameter (result, anonymousMethodExpression.Parameters);
result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AnonymousMethodExpression.Roles.RPar);
}
}
result.AddChild ((BlockStatement)anonymousMethodExpression.Block.Accept (this), AnonymousMethodExpression.Roles.Body);
return result;
}
void start_anonymous (bool isLambda, ParametersCompiled parameters, bool isAsync, Location loc)
{
oob_stack.Push (current_anonymous_method);
oob_stack.Push (current_local_parameters);
oob_stack.Push (current_variable);
oob_stack.Push (async_block);
current_local_parameters = parameters;
if (isLambda) {
if (lang_version <= LanguageVersion.ISO_2)
FeatureIsNotAvailable (loc, "lambda expressions");
current_anonymous_method = new LambdaExpression (loc);
} else {
if (lang_version == LanguageVersion.ISO_1)
FeatureIsNotAvailable (loc, "anonymous methods");
current_anonymous_method = new AnonymousMethodExpression (loc);
}
current_anonymous_method.IsAsync = isAsync;
async_block = isAsync;
// Force the next block to be created as a ToplevelBlock
parsing_anonymous_method = true;
}
public virtual object Visit (AnonymousMethodExpression anonymousMethodExpression)
{
return null;
}
/*
* Completes the anonymous method processing, if lambda_expr is null, this
* means that we have a Statement instead of an Expression embedded
*/
AnonymousMethodExpression end_anonymous (ParametersBlock anon_block)
{
AnonymousMethodExpression retval;
current_anonymous_method.Block = anon_block;
retval = current_anonymous_method;
current_variable = (BlockVariableDeclaration) oob_stack.Pop ();
current_local_parameters = (ParametersCompiled) oob_stack.Pop ();
current_anonymous_method = (AnonymousMethodExpression) oob_stack.Pop ();
return retval;
}
void start_anonymous (bool lambda, ParametersCompiled parameters, Location loc)
{
if (RootContext.Version == LanguageVersion.ISO_1){
Report.FeatureIsNotAvailable (loc, "anonymous methods");
}
oob_stack.Push (current_anonymous_method);
oob_stack.Push (current_local_parameters);
oob_stack.Push (current_variable);
current_local_parameters = parameters;
current_anonymous_method = lambda
? new LambdaExpression (loc)
: new AnonymousMethodExpression (loc);
// Force the next block to be created as a ToplevelBlock
parsing_anonymous_method = true;
}
public AsLocalFunction (Location loc, string name, AnonymousMethodExpression methodExpr, BlockVariableDeclaration varDecl)
{
this.loc = loc;
this.Name = name;
this.MethodExpr = methodExpr;
this.VarDecl = varDecl;
}
static Expression DoImplicitConversionStandard (ResolveContext ec, Expression expr, TypeSpec target_type, Location loc, bool explicit_cast, bool upconvert_only)
{
if (expr.eclass == ExprClass.MethodGroup){
if (!target_type.IsDelegate){
if (ec.FileType == SourceFileType.PlayScript &&
(target_type == ec.BuiltinTypes.Dynamic || target_type == ec.BuiltinTypes.Delegate)) {
MethodGroupExpr mg = expr as MethodGroupExpr;
if (mg != null) {
if (mg.Candidates.Count != 1) {
ec.Report.Error (7021, loc, "Ambiguous overloaded methods `{0}' when assigning to Function or Object type", mg.Name);
return null;
}
var ms = (MethodSpec)mg.Candidates[0];
var del_type = Delegate.CreateDelegateTypeFromMethodSpec(ec, ms, loc);
// If return is "Delegate", we create a var args anonymous method which calls the target method..
if (del_type == ec.BuiltinTypes.Delegate) {
var objArrayType = new ComposedCast (
new TypeExpression(ec.BuiltinTypes.Object, loc),
ComposedTypeSpecifier.CreateArrayDimension (1, loc));
var parameters = new ParametersCompiled(new Parameter[] {
new ParamsParameter(objArrayType, "args", null, loc) }, false);
var dynCall = new AnonymousMethodExpression(expr.Location, parameters, new TypeExpression(ms.ReturnType, loc));
var block = new ParametersBlock (ec.CurrentBlock, parameters, expr.Location);
dynCall.Block = block;
var args = new Arguments (3);
args.Add (new Argument(new TypeOf(new TypeExpression(ms.DeclaringType, loc), loc)));
args.Add (new Argument(new StringLiteral(ec.BuiltinTypes, ms.Name, loc)));
args.Add (new Argument(new SimpleName("args", loc)));
var call = new Invocation (new MemberAccess(new MemberAccess(new SimpleName("PlayScript", loc), "Support", loc), "VarArgCall", loc), args);
if (ms.ReturnType == ec.BuiltinTypes.Void) {
block.AddStatement (new StatementExpression(call));
} else {
block.AddStatement (new Return(call, loc));
}
return dynCall.Resolve (ec);
} else {
// Otherwise cast to the specific delegate type
return new ImplicitDelegateCreation (del_type, mg, loc).Resolve (ec);
}
}
}
return null;
}
//
// Only allow anonymous method conversions on post ISO_1
//
if (ec.Module.Compiler.Settings.Version != LanguageVersion.ISO_1){
MethodGroupExpr mg = expr as MethodGroupExpr;
if (mg != null)
return new ImplicitDelegateCreation (target_type, mg, loc).Resolve (ec);
}
}
TypeSpec expr_type = expr.Type;
Expression e;
if (expr_type == target_type) {
if (expr_type != InternalType.NullLiteral && expr_type != InternalType.AnonymousMethod)
return expr;
return null;
}
// Auto convert types to type objects..
if (ec.FileType == SourceFileType.PlayScript && target_type.BuiltinType == BuiltinTypeSpec.Type.Type && expr is FullNamedExpression) {
FullNamedExpression type_expr = (FullNamedExpression)expr;
if (expr_type != null) {
if (expr_type.MemberDefinition.Namespace == PsConsts.PsRootNamespace) {
switch (expr_type.Name) {
case "String":
type_expr = new TypeExpression (ec.BuiltinTypes.String, type_expr.Location);
break;
case "Number":
type_expr = new TypeExpression (ec.BuiltinTypes.Double, type_expr.Location);
break;
case "Boolean":
type_expr = new TypeExpression (ec.BuiltinTypes.Double, type_expr.Location);
break;
}
} else if (expr_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
type_expr = new TypeExpression (ec.Module.PredefinedTypes.AsObject.Resolve(), type_expr.Location);
}
}
return new TypeOf (type_expr, expr.Location).Resolve (ec);
}
if (expr_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
// Implicitly cast references to bools in PlayScript
if (ec.FileType == SourceFileType.PlayScript &&
target_type.BuiltinType == BuiltinTypeSpec.Type.Bool &&
ec.Target != Target.JavaScript) {
var cast_args = new Arguments(1);
cast_args.Add (new Argument(EmptyCast.Create(expr, ec.BuiltinTypes.Object)));
// ec.Report.Warning (7164, 1, expr.Location, "Expensive reference conversion to bool");
return new Invocation(new MemberAccess(new MemberAccess(new SimpleName(
PsConsts.PsRootNamespace, expr.Location), "Boolean_fn", expr.Location), "Boolean", expr.Location),
cast_args).Resolve (ec);
}
switch (target_type.Kind) {
case MemberKind.ArrayType:
case MemberKind.Class:
if (target_type.BuiltinType == BuiltinTypeSpec.Type.Object)
return EmptyCast.Create (expr, target_type);
goto case MemberKind.Struct;
case MemberKind.Struct:
case MemberKind.Delegate:
case MemberKind.Enum:
case MemberKind.Interface:
case MemberKind.TypeParameter:
Arguments args = new Arguments (1);
args.Add (new Argument (expr));
return new DynamicConversion (target_type, explicit_cast ? CSharpBinderFlags.ConvertExplicit : 0, args, loc).Resolve (ec);
}
return null;
}
if (target_type.IsNullableType)
return ImplicitNulableConversion (ec, expr, target_type);
//
// Attempt to do the implicit constant expression conversions
//
Constant c = expr as Constant;
if (c != null) {
try {
c = c.ConvertImplicitly (target_type, ec, upconvert_only);
} catch {
throw new InternalErrorException ("Conversion error", loc);
}
if (c != null)
return c;
}
e = ImplicitNumericConversion (expr, expr_type, target_type, ec, upconvert_only);
if (e != null)
return e;
e = ImplicitPlayScriptConversion (expr, target_type, ec, upconvert_only);
if (e != null)
return e;
e = ImplicitReferenceConversion (expr, target_type, explicit_cast, ec, upconvert_only);
if (e != null)
return e;
e = ImplicitBoxingConversion (expr, expr_type, target_type);
if (e != null)
return e;
if (expr is IntegralConstant && target_type.IsEnum){
var i = (IntegralConstant) expr;
//
// LAMESPEC: csc allows any constant like 0 values to be converted, including const float f = 0.0
//
// An implicit enumeration conversion permits the decimal-integer-literal 0
// to be converted to any enum-type and to any nullable-type whose underlying
// type is an enum-type
//
if (i.IsZeroInteger) {
// Recreate 0 literal to remove any collected conversions
return new EnumConstant (new IntLiteral (ec.BuiltinTypes, 0, i.Location), target_type);
}
}
if (ec.IsUnsafe) {
var target_pc = target_type as PointerContainer;
if (target_pc != null) {
if (expr_type.IsPointer) {
//
// Pointer types are same when they have same element types
//
if (expr_type == target_pc)
return expr;
if (target_pc.Element.Kind == MemberKind.Void)
return EmptyCast.Create (expr, target_type);
//return null;
}
if (expr_type == InternalType.NullLiteral)
return new NullPointer (target_type, loc);
}
}
if (expr_type == InternalType.AnonymousMethod){
AnonymousMethodExpression ame = (AnonymousMethodExpression) expr;
if (ec.FileType == SourceFileType.PlayScript &&
(target_type == ec.BuiltinTypes.Dynamic || target_type == ec.BuiltinTypes.Delegate)) {
var del_type = Delegate.CreateDelegateType (ec, ame.AsParameters, ame.AsReturnType.ResolveAsType(ec), loc);
return new Cast(new TypeExpression(del_type, loc), expr, loc).Resolve(ec);
}
Expression am = ame.Compatible (ec, target_type);
if (am != null)
return am.Resolve (ec);
}
if (expr_type == InternalType.Arglist && target_type == ec.Module.PredefinedTypes.ArgIterator.TypeSpec)
return expr;
//
// dynamic erasure conversion on value types
//
if (expr_type.IsStruct && TypeSpecComparer.IsEqual (expr_type, target_type))
return expr_type == target_type ? expr : EmptyCast.Create (expr, target_type);
return null;
}