private Expression ImplementInitializingMixins(ThisExpression @this, IList <Type> expectedMixinTypes, Expression isDeserialization)
{
var mixinInitExpressions = new List <Expression>();
for (int i = 0; i < expectedMixinTypes.Count; i++)
{
if (typeof(IInitializableMixin).IsTypePipeAssignableFrom(expectedMixinTypes[i]))
{
// ((IInitializableMixin) __extensions[i]).Initialize (mixinTargetInstance, <NewNextCallProxy (i + 1)>, isDeserialization);
var initExpression = Expression.Call(
Expression.Convert(
Expression.ArrayAccess(_extensionsField, Expression.Constant(i)),
typeof(IInitializableMixin)),
s_initializeMixinMethod,
@this,
NewNextCallProxy(@this, i + 1),
isDeserialization);
mixinInitExpressions.Add(initExpression);
}
}
return(Expression.BlockOrEmpty(mixinInitExpressions));
}
public override INode VisitThisExpression(ThisExpression thisExpression)
{
return(new ThisExpression(thisExpression.Context)
{
Type = thisExpression.Type
});
}
public void ThisExpression()
{
var e = new ThisExpression();
Assert.IsTrue(e.IsTrivial);
Assert.AreEqual("this", e.ToString());
}
/// <inheritdoc />
protected override EvaluationResult DoEval(Context context, ModuleLiteral env, EvaluationStackFrame frame)
{
var receiver = ThisExpression.Eval(context, env, frame);
if (receiver.IsErrorValue)
{
return(EvaluationResult.Error);
}
if (receiver.Value is ObjectLiteral obj)
{
if (Selector.GetParent(context.FrontEndContext.SymbolTable) != FullSymbol.Invalid)
{
context.Errors.ReportFailResolveModuleSelector(env, this);
return(EvaluationResult.Error);
}
return(obj.GetOrEvalField(
context,
Selector.GetName(context.FrontEndContext.SymbolTable),
recurs: false,
origin: env,
location: Location));
}
context.Errors.ReportUnexpectedValueType(
env,
ThisExpression,
receiver, new[] { typeof(ModuleLiteral), typeof(ObjectLiteral) });
return(EvaluationResult.Error);
}
public void SetUp()
{
_declaringType = ObjectMother.GetMutableType();
_parameterExpression1 = ObjectMother.GetParameterExpression(typeof(string), "param1");
_parameterExpression2 = ObjectMother.GetParameterExpression(typeof(int), "param2");
_thisExpression = new ThisExpression(_declaringType);
_callExpressionHelperMock = MockRepository.GenerateStrictMock <ICallExpressionHelper> ();
_invocationType = typeof(FuncContext <object, string, int, int>);
_memberFieldMock = MockRepository.GenerateStrictMock <IStorage> ();
_delegateFieldMock = MockRepository.GenerateStrictMock <IStorage> ();
_aspectFieldMock1 = MockRepository.GenerateStrictMock <IStorage> ();
_aspectFieldMock2 = MockRepository.GenerateStrictMock <IStorage> ();
_adviceMethod1 = ObjectMother.GetMethodInfo();
_adviceMethod2 = ObjectMother.GetMethodInfo();
var advices = new[] { Tuple.Create(_adviceMethod1, _aspectFieldMock1), Tuple.Create(_adviceMethod2, _aspectFieldMock2) };
_expressionHelper = new InterceptionExpressionHelper(
_callExpressionHelperMock,
_thisExpression,
new[] { _parameterExpression1, _parameterExpression2 },
_invocationType,
advices,
_memberFieldMock,
_delegateFieldMock);
}
/// <inheritdoc />
protected override EvaluationResult DoEval(Context context, ModuleLiteral env, EvaluationStackFrame frame)
{
var e = ThisExpression.Eval(context, env, frame);
if (e.IsErrorValue)
{
return(EvaluationResult.Error);
}
var indexObj = Index.Eval(context, env, frame);
if (indexObj.IsErrorValue)
{
return(EvaluationResult.Error);
}
// Extracting local to avoid casting multiple times
var stringIndexer = indexObj.Value as string;
if (e.Value is ArrayLiteral arrayLiteral)
{
if (indexObj.Value is int index)
{
if (index < 0 || index >= arrayLiteral.Length)
{
// This behavior is different from the TypeScript one, but this is actually helpful
context.Errors.ReportArrayIndexOufOfRange(env, this, index, arrayLiteral.Length);
return(EvaluationResult.Error);
}
return(arrayLiteral[index]);
}
// indexer for an array can be a number for getting elements, or string
if (stringIndexer == null)
{
context.Errors.ReportUnexpectedValueType(env, Index, indexObj, typeof(int), typeof(string));
return(EvaluationResult.Error);
}
// Falling back to object literal case if the indexer is a string.
}
if (e.Value is ObjectLiteral objectLiteral)
{
if (stringIndexer != null)
{
var selectorId = context.FrontEndContext.StringTable.AddString(stringIndexer);
return(objectLiteral.GetOrEvalField(context, selectorId, recurs: false, origin: env, location: Location));
}
context.Errors.ReportUnexpectedValueType(env, Index, indexObj, typeof(string));
return(EvaluationResult.Error);
}
// Indexer in typescript never fails and return undefined.
// Following this pattern.
return(EvaluationResult.Undefined);
}
public Expression VisitThis(ThisExpression node)
{
ArgumentUtility.CheckNotNull("node", node);
_ilGenerator.Emit(OpCodes.Ldarg_0);
return(node);
}
public ThisAction(ParseInfo parseInfo, Scope scope, ThisExpression context)
{
ThisType = scope.GetThis();
if (ThisType == null)
{
parseInfo.Script.Diagnostics.Error("Keyword 'this' cannot be used here.", context.Range);
}
}
public void ShouldParseThis()
{
var program = new Parser.Parser("this").ParseScript();
var body = program.scriptBody.statements;
Assert.Single(body);
Assert.Equal(ThisExpression.Instance(false), body.First().As <ExpressionStatement>().expression.As <ThisExpression>());
}
public static MethodExecutionExpression Adapt(MutableMethodInfo method)
{
var instance = new ThisExpression(method.DeclaringType);
var baseMethod = NonVirtualCallMethodInfoAdapter.Adapt(method.UnderlyingSystemMethodInfo);
var parameters = method.ParameterExpressions.Cast <Expression>();
var body = Call(instance, baseMethod, parameters);
return(new MethodExecutionExpression(method, body));
}
public override object Visit(ThisExpression node, object obj)
{
if (node.Location == ((AstNode)obj).Location || found)
{
found = true;
return(this.table);
}
return(base.Visit(node, obj));
}
public Expression VisitThis(ThisExpression node)
{
var name = "__value";
if (HoistedLocals.ContainsKey(name) == false)
{
HoistedLocals.Add(name, node);
}
return(node);
}
public object VisitThis(ThisExpression node)
{
if (Target is object)
{
node.Type = Target.GetType();
return(Target);
}
node.Type = TypeProvider.ObjectType;
return(NoTarget);
}
public Unit VisitThisExpression(ThisExpression expression)
{
if (_currentClass == ClassType.None)
{
throw new ResolveException("Can't use 'this' outside of class");
}
ResolveLocal(expression, expression.Token);
return(Unit.Value);
}
public object VisitThisExpression(ThisExpression expression)
{
if (scope.InClass)
{
scope.ResolveValue(expression, expression.Keyword);
}
else
{
Interpreter.ScopeError(expression.Keyword, "Cannot use 'this' outside of a class.");
}
return(null);
}
/// <summary>
/// Validation, checking whether the member is a valid property.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public MemberExpression Validate(IValidationScope context)
{
var @this = ThisExpression.Validate(context);
var thisType = @this.SemanticType;
var csharpType = context.TypeSystem.GetTypeByNative(thisType);
var symbol = csharpType.GetByName(Delimiter, MemberName);
if (!(symbol is IProperty))
{
throw new LocateableException(Location, "Expecting property!");
}
validatedProperty = symbol as IProperty;
SemanticType = validatedProperty.ReturnType;
return(this);
}
/// <summary>
/// Outputs a user-friendly representation of this expression.
/// </summary>
/// <returns></returns>
public override string ToString()
{
var delimiter = "";
switch (Delimiter)
{
case IdDelimiter.Dollar: delimiter = "$"; break;
case IdDelimiter.Dot: delimiter = "."; break;
case IdDelimiter.Hash: delimiter = "#"; break;
case IdDelimiter.SingleArrow: delimiter = "->"; break;
case IdDelimiter.Slash: delimiter = "/"; break;
}
return($"{ThisExpression.ToString()}{delimiter}{MemberName}");
}
public static ThisExpression Create(
AphidExpressionContext context_aphidExpressionContext,
int value_i,
int value_i1
)
{
ThisExpression thisExpression
= new ThisExpression(context_aphidExpressionContext);
((AphidExpression)thisExpression).Index = value_i;
((AphidExpression)thisExpression).Length = value_i1;
return(thisExpression);
// TODO: Edit factory method of ThisExpression
// This method should be able to configure the object in all possible ways.
// Add as many parameters as needed,
// and assign their values to each field by using the API.
}
/// <summary>
/// Adds new assignment statements at the end of the specified block.
/// </summary>
/// <param name="vars">Information of the current scope in SSAMap.</param>
/// <param name="node">Block of statement to add the new declarations.</param>
private void addAssignmentStatements(Dictionary <string, SSAElement> vars, Block node)
{
FieldAccessExpression op1;
SingleIdentifierExpression eop1;
SingleIdentifierExpression op2;
ThisExpression th = new ThisExpression(node.Location);
foreach (KeyValuePair <string, SSAElement> pair in vars)
{
if (pair.Value.IndexSSA > 0)
{
eop1 = new SingleIdentifierExpression(pair.Key.Substring(6, pair.Key.Length - 6), node.Location);
eop1.IndexOfSSA = -1;
op1 = new FieldAccessExpression(th, eop1, node.Location);
op2 = new SingleIdentifierExpression(pair.Key, node.Location);
op2.IndexOfSSA = pair.Value.IndexSSA;
node.AddStatement(new AssignmentExpression(op1, op2, AssignmentOperator.Assign, node.Location));
}
}
}
/// <inheritdoc />
protected override EvaluationResult DoEval(Context context, ModuleLiteral env, EvaluationStackFrame frame)
{
var receiver = ThisExpression.Eval(context, env, frame);
if (receiver.IsErrorValue)
{
return(EvaluationResult.Error);
}
if (receiver.IsUndefined)
{
context.Errors.ReportFailResolveSelectorDueToUndefined(env, this);
return(EvaluationResult.Error);
}
if (receiver.Value is Expression thisExpressionResult)
{
if (thisExpressionResult.TryProject(context, Selector, env, context.PredefinedTypes, out EvaluationResult projectionResult, Location))
{
return(projectionResult);
}
context.Errors.ReportUnexpectedValueType(
env,
ThisExpression,
receiver, typeof(ObjectLiteral), typeof(ArrayLiteral), typeof(ModuleLiteral));
return(EvaluationResult.Error);
}
// Trying to find member function for well-known types.
var boundMember = context.PredefinedTypes.ResolveMember(receiver.Value, Selector);
if (boundMember != null)
{
// If bound member represents a property we need to evaluate it.
return(boundMember.IsProperty ? EvaluateAmbientProperty(context, env, boundMember) : EvaluationResult.Create(boundMember));
}
context.Errors.ReportMissingProperty(env, Selector, receiver.Value, Location);
return(EvaluationResult.Error);
}
public override void ExitThisExpression(ThisExpression thisExpression)
{
var classDeclaration = thisExpression.NearestAncestorOfType <ClassDeclaration>();
if (classDeclaration == null)
{
Errors.Add(new CompilationError(thisExpression.Context, "The this keyword can only be used inside classes"));
thisExpression.Type = new NullType();
}
else if (classDeclaration.GenericTypeDeclarations.Any())
{
thisExpression.Type = new GenericType(thisExpression.Context,
ReferenceToType(thisExpression.Context, classDeclaration).Yield()
.Concat(classDeclaration.GenericTypeDeclarations.Select(x => ReferenceToType(thisExpression.Context, x)))
);
}
else
{
thisExpression.Type = ReferenceToType(thisExpression.Context, classDeclaration);
}
}
public JsValue EvaluateThisExpression(ThisExpression thisExpression)
{
return _engine.ExecutionContext.ThisBinding;
}
/// <inheritdoc />
public override string ToDebugString()
{
return(I($"{ThisExpression.ToDebugString()}.{ToDebugString(Selector)}"));
}
/// <inheritdoc />
public override string ToStringShort(StringTable stringTable)
{
return(I($"{ThisExpression.ToStringShort(stringTable)}.{Selector.ToString(stringTable)}"));
}
/// <inheritdoc />
protected override void DoSerialize(BuildXLWriter writer)
{
ThisExpression.Serialize(writer);
writer.Write(Selector);
}
protected virtual void Write(IndentedTextWriter writer, ThisExpression expression)
{
writer.Write("this");
}
public Expression ParseFactor()
{
Expression exp;
switch (_currentToken.TokenType)
{
case AphidTokenType.LeftBrace:
exp = ParseObjectExpression();
break;
case AphidTokenType.LeftBracket:
exp = ParseArrayExpression();
break;
case AphidTokenType.LeftParenthesis:
NextToken();
exp = ParseExpression();
Match(AphidTokenType.RightParenthesis);
break;
case AphidTokenType.String:
exp = ParseStringExpression();
break;
case AphidTokenType.Number:
exp = ParseNumberExpression();
break;
case AphidTokenType.MinusOperator:
NextToken();
var numExp = ParseNumberExpression();
numExp.Value *= -1;
exp = numExp;
break;
case AphidTokenType.Identifier:
exp = ParseIdentifierExpression();
if (_currentToken.TokenType == AphidTokenType.definedKeyword)
{
NextToken();
exp = new UnaryOperatorExpression(AphidTokenType.definedKeyword, exp)
{
IsPostfix = true
};
}
break;
case AphidTokenType.functionOperator:
exp = ParseFunctionExpression();
break;
//case AphidTokenType.forKeyword:
// exp = ParseForExpression();
// break;
case AphidTokenType.retKeyword:
case AphidTokenType.deleteKeyword:
exp = ParseUnaryExpression();
break;
case AphidTokenType.trueKeyword:
exp = new BooleanExpression(true);
NextToken();
break;
case AphidTokenType.falseKeyword:
exp = new BooleanExpression(false);
NextToken();
break;
case AphidTokenType.thisKeyword:
exp = new ThisExpression();
NextToken();
break;
//case AphidTokenType.extendKeyword:
// exp = ParseExtendExpression();
// break;
//case AphidTokenType.ifKeyword:
// exp = ParseIfExpression();
// break;
case AphidTokenType.LoadScriptOperator:
exp = ParseLoadScriptExpression();
break;
case AphidTokenType.LoadLibraryOperator:
exp = ParseLoadLibraryExpression();
break;
case AphidTokenType.nullKeyword:
exp = new NullExpression();
NextToken();
break;
case AphidTokenType.breakKeyword:
exp = new BreakExpression();
NextToken();
break;
case AphidTokenType.HexNumber:
exp = new NumberExpression((decimal)Convert.ToInt64(_currentToken.Lexeme.Substring(2), 16));
NextToken();
break;
case AphidTokenType.PatternMatchingOperator:
var matchExp = new PatternMatchingExpression();
NextToken();
Match(AphidTokenType.LeftParenthesis);
matchExp.TestExpression = ParseExpression();
Match(AphidTokenType.RightParenthesis);
while (true)
{
var tests = new List <Expression>();
while (true)
{
tests.Add(ParseExpression());
if (_currentToken.TokenType == AphidTokenType.Comma)
{
NextToken();
}
else
{
break;
}
}
if (_currentToken.TokenType == AphidTokenType.ColonOperator)
{
NextToken();
var b = ParseExpression();
foreach (var t in tests)
{
matchExp.Patterns.Add(new Tuple <Expression, Expression>(t, b));
}
}
else
{
matchExp.Patterns.Add(new Tuple <Expression, Expression>(null, tests[0]));
}
if (_currentToken.TokenType == AphidTokenType.Comma)
{
NextToken();
}
else
{
break;
}
}
exp = matchExp;
break;
default:
throw new AphidParserException(_currentToken);
}
return(exp);
}
public JsValue EvaluateThisExpression(ThisExpression thisExpression)
{
return(_engine.ExecutionContext.ThisBinding);
}
public MemberReferenceExpression(MemberDeclaration memberDeclaration)
{
TargetObject = new ThisExpression();
_memberDeclaration = memberDeclaration;
}
public virtual void Visit(ThisExpression node)
{
}
private static void WriteThis(CodeTextBuilder code, ThisExpression expression)
{
code.Write("this");
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public virtual void VisitThisExpression(ThisExpression expression)
{
VisitAbstractExpression(expression);
}
private void EmitThisExpression(ThisExpression e)
{
Write("this");
}
public void ThisExpressionProducesThis()
{
var expression = new ThisExpression();
Assert.AreEqual("this;", expression.ToString());
}
