protected void EliminateVariable(JSNode context, JSVariable variable, JSExpression replaceWith, QualifiedMemberIdentifier method)
{
{
var replacer = new VariableEliminator(
variable,
JSChangeTypeExpression.New(replaceWith, variable.GetActualType(TypeSystem), TypeSystem)
);
replacer.Visit(context);
}
{
var replacer = new VariableEliminator(variable, replaceWith);
var assignments = (from a in FirstPass.Assignments where
variable.Equals(a.NewValue) ||
a.NewValue.SelfAndChildrenRecursive.Any(variable.Equals)
select a).ToArray();
foreach (var a in assignments)
{
if (!variable.Equals(a.NewValue))
{
replacer.Visit(a.NewValue);
}
}
}
Variables.Remove(variable.Identifier);
FunctionSource.InvalidateFirstPass(method);
}
public static JSExpression FilterInvocationResult(
MethodReference methodReference, MethodInfo method,
JSExpression result,
ITypeInfoSource typeInfo, TypeSystem typeSystem
)
{
if (method == null)
{
return(result);
}
var resultType = result.GetActualType(typeSystem);
var resultIsPackedArray = PackedArrayUtil.IsPackedArrayType(resultType);
var returnValueAttribute = method.Metadata.GetAttribute("JSIL.Meta.JSPackedArrayReturnValueAttribute");
if (returnValueAttribute != null)
{
if (TypeUtil.IsOpenType(resultType))
{
// FIXME: We need to restrict substitution to when the result type is a generic parameter owned by the invocation...
resultType = JSExpression.SubstituteTypeArgs(typeInfo, resultType, methodReference);
}
if (!resultIsPackedArray)
{
return(JSChangeTypeExpression.New(result, PackedArrayUtil.MakePackedArrayType(resultType, returnValueAttribute.Entries.First().Type), typeSystem));
}
}
return(result);
}
public override JSExpression Translate (ILBlockTranslator translator, JSExpression[] arguments) {
var thisArgument = arguments[1];
var returnType = ReturnType;
if (returnType == null)
returnType = translator.TypeSystem.Void;
return new JSDelegateInvocationExpression(
JSChangeTypeExpression.New(thisArgument, returnType, translator.TypeSystem),
returnType, arguments.Skip(2).ToArray()
);
}
public void VisitNode(JSChangeTypeExpression cte)
{
var literal = cte.Expression as JSLiteral;
if (literal != null)
{
VisitLiteral(literal, cte.NewType);
}
else
{
// TODO: Mask if demotion?
Visit(cte.Expression);
}
}
protected void EliminateVariable(JSNode context, JSVariable variable, JSExpression replaceWith, QualifiedMemberIdentifier method)
{
{
var replacer = new VariableEliminator(
variable,
JSChangeTypeExpression.New(replaceWith, TypeSystem, variable.GetActualType(TypeSystem))
);
replacer.Visit(context);
}
{
var replacer = new VariableEliminator(variable, replaceWith);
var assignments = (from a in FirstPass.Assignments where
variable.Equals(a.NewValue) ||
a.NewValue.SelfAndChildrenRecursive.Any((_n) => variable.Equals(_n))
select a).ToArray();
foreach (var a in assignments)
{
if (variable.Equals(a.NewValue))
{
FirstPass.Assignments.Remove(a);
FirstPass.Assignments.Add(
new FunctionAnalysis1stPass.Assignment(
a.ParentNodeIndices, a.StatementIndex, a.NodeIndex,
a.Target, replaceWith, a.Operator,
a.TargetType, a.SourceType
)
);
}
else
{
replacer.Visit(a.NewValue);
}
}
}
Variables.Remove(variable.Identifier);
FunctionSource.InvalidateFirstPass(method);
}
public static JSExpression CastToEnumType(JSExpression value, TypeReference type, TypeSystem typeSystem)
{
if (IsNullableEnum(type))
{
// Handle casts like <int> -> <Enum?> by doing a two stage cast:
// <int> -> <Enum> -> <Enum?>
// Issue #154
var git = (GenericInstanceType)type;
var casted = JSCastExpression.New(
value, git.GenericArguments[0], typeSystem, true
);
var coerced = JSChangeTypeExpression.New(
casted, type, typeSystem
);
return(coerced);
}
else
{
return(JSCastExpression.New(
value, type, typeSystem, true
));
}
}
public void VisitNode(JSBinaryOperatorExpression boe)
{
var boeType = boe.GetActualType(TypeSystem);
var typeToken = WasmUtil.PickTypeKeyword(boeType);
if (boe.Operator == JSOperator.Assignment)
{
Assign(boe.Left, boe.Right);
return;
}
string keyword;
if (!OperatorTable.TryGetValue(boe.Operator, out keyword))
{
Console.WriteLine("Unimplemented operator {0}", boe.Operator);
return;
}
var leftType = boe.Left.GetActualType(TypeSystem);
var rightType = boe.Right.GetActualType(TypeSystem);
var leftSign = TypeUtil.IsSigned(leftType);
// HACK: Emit the argument type since we're comparing it
if (boe.Operator is JSComparisonOperator)
{
typeToken = WasmUtil.PickTypeKeyword(leftType);
}
var signSuffix = "";
if (
(leftSign.HasValue && TypeUtil.IsIntegral(leftType)) ||
// HACK
(leftType.FullName == "System.Char")
)
{
signSuffix = leftSign.GetValueOrDefault(true)
? "_s"
: "_u";
}
else if (
TypeUtil.IsPointer(leftType) ||
TypeUtil.IsPointer(rightType)
)
{
signSuffix = "_u";
}
var actualKeyword = string.Format(
typeToken + "." + keyword,
signSuffix
);
// HACK: wasm i64 shift takes i64 shift amount
var right = boe.Right;
if (
(boe.Operator == JSOperator.ShiftLeft) ||
(boe.Operator == JSOperator.ShiftRight)
)
{
right = JSChangeTypeExpression.New(right, leftType, TypeSystem);
}
if (typeToken == null)
{
Console.WriteLine("Unhandled binary operator type {0} ({1})", boeType, boe);
return;
}
Formatter.WriteSExpr(
actualKeyword,
(_) => EmitArgumentList(_, new[] { boe.Left, right }, true),
true, false
);
}
public void VisitNode(JSChangeTypeExpression cte)
{
Visit(cte.Expression);
}
