public void Visit(ObjectLiteral node)
{
if (node != null)
{
DoesRequire = true;
}
}
public void Visit(ObjectLiteral node)
{
if (node != null)
{
m_writer.Write('{');
if (node.Properties != null)
{
// if this is multi-line output, we're going to want to run some checks first
// to see if we want to put the array all on one line or put elements on separate lines.
var multiLine = false;
if (m_settings.OutputMode == OutputMode.MultipleLines)
{
if (node.Properties.Count > 5 || NotJustPrimitives(node.Properties))
{
multiLine = true;
}
}
if (multiLine)
{
// multiline -- let's pretty it up a bit
m_settings.Indent();
try
{
var first = true;
foreach (var property in node.Properties)
{
if (first)
{
first = false;
}
else
{
m_writer.Write(',');
}
NewLine();
property.Accept(this);
}
}
finally
{
m_settings.Unindent();
}
NewLine();
}
else
{
node.Properties.Accept(this);
}
}
m_writer.Write('}');
}
}
public override void Visit(ObjectLiteral node)
{
base.Visit(node);
foreach(var function in this.functions.Children) {
node.Properties.Insert(node.Properties.Count, new ObjectLiteralProperty(node.Context) {
Name = new ObjectLiteralField((function as FunctionObject).Binding.Name, PrimitiveType.String, node.Context),
Value = function
});
}
}
public void Visit(ObjectLiteral node)
{
// NOT safe -- if it starts a statement off, it would be interpreted as a block,
// not an object literal.
m_isSafe = false;
}
public void Visit(ObjectLiteral node)
{
// we're good
}
internal override void AnalyzeNode()
{
// see if this is a member (we'll need it for a couple checks)
Member member = m_func as Member;
if (Parser.Settings.StripDebugStatements && Parser.Settings.IsModificationAllowed(TreeModifications.StripDebugStatements))
{
// if this is a member, and it's a debugger object, and it's a constructor....
if (member != null && member.IsDebuggerStatement && m_isConstructor)
{
// we need to replace our debugger object with a generic Object
m_func = new Lookup("Object", m_func.Context, Parser);
// and make sure the node list is empty
if (m_args != null && m_args.Count > 0)
{
m_args = new AstNodeList(m_args.Context, Parser);
}
}
}
// if this is a constructor and we want to collapse
// some of them to literals...
if (m_isConstructor && Parser.Settings.CollapseToLiteral)
{
// see if this is a lookup, and if so, if it's pointing to one
// of the two constructors we want to collapse
Lookup lookup = m_func as Lookup;
if (lookup != null)
{
if (lookup.Name == "Object" &&
Parser.Settings.IsModificationAllowed(TreeModifications.NewObjectToObjectLiteral))
{
// no arguments -- the Object constructor with no arguments is the exact same as an empty
// object literal
if (m_args == null || m_args.Count == 0)
{
// replace our node with an object literal
ObjectLiteral objLiteral = new ObjectLiteral(Context, Parser, null, null);
if (Parent.ReplaceChild(this, objLiteral))
{
// and bail now. No need to recurse -- it's an empty literal
return;
}
}
else if (m_args.Count == 1)
{
// one argument
// check to see if it's an object literal.
ObjectLiteral objectLiteral = m_args[0] as ObjectLiteral;
if (objectLiteral != null)
{
// the Object constructor with an argument that is a JavaScript object merely returns the
// argument. Since the argument is an object literal, it is by definition a JavaScript object
// and therefore we can replace the constructor call with the object literal
Parent.ReplaceChild(this, objectLiteral);
// don't forget to recurse the object now
objectLiteral.AnalyzeNode();
// and then bail -- we don't want to process this call
// operation any more; we've gotten rid of it
return;
}
}
}
else if (lookup.Name == "Array" &&
Parser.Settings.IsModificationAllowed(TreeModifications.NewArrayToArrayLiteral))
{
// Array is trickier.
// If there are no arguments, then just use [].
// if there are multiple arguments, then use [arg0,arg1...argN].
// but if there is one argument and it's numeric, we can't crunch it.
// also can't crunch if it's a function call or a member or something, since we won't
// KNOW whether or not it's numeric.
//
// so first see if it even is a single-argument constant wrapper.
ConstantWrapper constWrapper = (m_args != null && m_args.Count == 1 ? m_args[0] as ConstantWrapper : null);
// if the argument count is not one, then we crunch.
// if the argument count IS one, we only crunch if we have a constant wrapper,
// AND it's not numeric.
if (m_args == null ||
m_args.Count != 1 ||
(constWrapper != null && !constWrapper.IsNumericLiteral))
{
// create the new array literal object
ArrayLiteral arrayLiteral = new ArrayLiteral(Context, Parser, m_args);
// replace ourself within our parent
if (Parent.ReplaceChild(this, arrayLiteral))
{
// recurse
arrayLiteral.AnalyzeNode();
// and bail -- we don't want to recurse this node any more
return;
}
}
}
}
}
// if we are replacing resource references with strings generated from resource files
// and this is a brackets call: lookup[args]
ResourceStrings resourceStrings = Parser.ResourceStrings;
if (m_inBrackets && resourceStrings != null && resourceStrings.Count > 0)
{
// see if the root object is a lookup that corresponds to the
// global value (not a local field) for our resource object
// (same name)
Lookup rootLookup = m_func as Lookup;
if (rootLookup != null &&
rootLookup.LocalField == null &&
string.CompareOrdinal(rootLookup.Name, resourceStrings.Name) == 0)
{
// we're going to replace this node with a string constant wrapper
// but first we need to make sure that this is a valid lookup.
// if the parameter contains anything that would vary at run-time,
// then we need to throw an error.
// the parser will always have either one or zero nodes in the arguments
// arg list. We're not interested in zero args, so just make sure there is one
if (m_args.Count == 1)
{
// must be a constant wrapper
ConstantWrapper argConstant = m_args[0] as ConstantWrapper;
if (argConstant != null)
{
string resourceName = argConstant.Value.ToString();
// get the localized string from the resources object
ConstantWrapper resourceLiteral = new ConstantWrapper(
resourceStrings[resourceName],
PrimitiveType.String,
Context,
Parser);
// replace this node with localized string, analyze it, and bail
// so we don't anaylze the tree we just replaced
Parent.ReplaceChild(this, resourceLiteral);
resourceLiteral.AnalyzeNode();
return;
}
else
{
// error! must be a constant
Context.HandleError(
JSError.ResourceReferenceMustBeConstant,
true);
}
}
else
{
// error! can only be a single constant argument to the string resource object.
// the parser will only have zero or one arguments, so this must be zero
// (since the parser won't pass multiple args to a [] operator)
Context.HandleError(
JSError.ResourceReferenceMustBeConstant,
true);
}
}
}
// and finally, if this is a backets call and the argument is a constantwrapper that can
// be an identifier, just change us to a member node: obj["prop"] to obj.prop.
// but ONLY if the string value is "safe" to be an identifier. Even though the ECMA-262
// spec says certain Unicode categories are okay, in practice the various major browsers
// all seem to have problems with certain characters in identifiers. Rather than risking
// some browsers breaking when we change this syntax, don't do it for those "danger" categories.
if (m_inBrackets && m_args != null)
{
// see if there is a single, constant argument
string argText = m_args.SingleConstantArgument;
if (argText != null)
{
// see if we want to replace the name
string newName;
if (Parser.Settings.HasRenamePairs && Parser.Settings.ManualRenamesProperties &&
Parser.Settings.IsModificationAllowed(TreeModifications.PropertyRenaming) &&
!string.IsNullOrEmpty(newName = Parser.Settings.GetNewName(argText)))
{
// yes -- we are going to replace the name, either as a string literal, or by converting
// to a member-dot operation.
// See if we can't turn it into a dot-operator. If we can't, then we just want to replace the operator with
// a new constant wrapper. Otherwise we'll just replace the operator with a new constant wrapper.
if (Parser.Settings.IsModificationAllowed(TreeModifications.BracketMemberToDotMember) &&
JSScanner.IsSafeIdentifier(newName) &&
!JSScanner.IsKeyword(newName))
{
// the new name is safe to convert to a member-dot operator.
// but we don't want to convert the node to the NEW name, because we still need to Analyze the
// new member node -- and it might convert the new name to something else. So instead we're
// just going to convert this existing string to a member node WITH THE OLD STRING,
// and THEN analyze it (which will convert the old string to newName)
Member replacementMember = new Member(Context, Parser, m_func, argText);
Parent.ReplaceChild(this, replacementMember);
// this analyze call will convert the old-name member to the newName value
replacementMember.AnalyzeNode();
return;
}
else
{
// nope; can't convert to a dot-operator.
// we're just going to replace the first argument with a new string literal
// and continue along our merry way.
m_args.ReplaceChild(m_args[0], new ConstantWrapper(newName, PrimitiveType.String, m_args[0].Context, Parser));
}
}
else if (Parser.Settings.IsModificationAllowed(TreeModifications.BracketMemberToDotMember) &&
JSScanner.IsSafeIdentifier(argText) &&
!JSScanner.IsKeyword(argText))
{
// not a replacement, but the string literal is a safe identifier. So we will
// replace this call node with a Member-dot operation
Member replacementMember = new Member(Context, Parser, m_func, argText);
Parent.ReplaceChild(this, replacementMember);
replacementMember.AnalyzeNode();
return;
}
}
}
// call the base class to recurse
base.AnalyzeNode();
// call this AFTER recursing to give the fields a chance to resolve, because we only
// want to make this replacement if we are working on the global Date object.
if (!m_inBrackets && !m_isConstructor &&
(m_args == null || m_args.Count == 0) &&
member != null && string.CompareOrdinal(member.Name, "getTime") == 0 &&
Parser.Settings.IsModificationAllowed(TreeModifications.DateGetTimeToUnaryPlus))
{
// this is not a constructor and it's not a brackets call, and there are no arguments.
// if the function is a member operation to "getTime" and the object of the member is a
// constructor call to the global "Date" object (not a local), then we want to replace the call
// with a unary plus on the Date constructor. Converting to numeric type is the same as
// calling getTime, so it's the equivalent with much fewer bytes.
CallNode dateConstructor = member.Root as CallNode;
if (dateConstructor != null &&
dateConstructor.IsConstructor)
{
// lookup for the predifined (not local) "Date" field
Lookup lookup = dateConstructor.Function as Lookup;
if (lookup != null && string.CompareOrdinal(lookup.Name, "Date") == 0 &&
lookup.LocalField == null)
{
// this is in the pattern: (new Date()).getTime()
// we want to replace it with +new Date
// use the same date constructor node as the operand
NumericUnary unary = new NumericUnary(Context, Parser, dateConstructor, JSToken.Plus);
// replace us (the call to the getTime method) with this unary operator
Parent.ReplaceChild(this, unary);
// don't need to AnalyzeNode on the unary operator. The operand has already
// been analyzed when we recursed, and the unary operator wouldn't do anything
// special anyway (since the operand is not a numeric constant)
}
}
}
else if (Parser.Settings.EvalTreatment != EvalTreatment.Ignore)
{
// if this is a window.eval call, then we need to mark this scope as unknown just as
// we would if this was a regular eval call.
// (unless, of course, the parser settings say evals are safe)
// call AFTER recursing so we know the left-hand side properties have had a chance to
// lookup their fields to see if they are local or global
if (member != null && string.CompareOrdinal(member.Name, "eval") == 0)
{
if (member.LeftHandSide.IsWindowLookup)
{
// this is a call to window.eval()
// mark this scope as unknown so we don't crunch out locals
// we might reference in the eval at runtime
ScopeStack.Peek().IsKnownAtCompileTime = false;
}
}
else
{
CallNode callNode = m_func as CallNode;
if (callNode != null &&
callNode.InBrackets &&
callNode.LeftHandSide.IsWindowLookup &&
callNode.Arguments.IsSingleConstantArgument("eval"))
{
// this is a call to window["eval"]
// mark this scope as unknown so we don't crunch out locals
// we might reference in the eval at runtime
ScopeStack.Peek().IsKnownAtCompileTime = false;
}
}
}
/* REVIEW: may be too late. lookups may alread have been analyzed and
* found undefined
* // check to see if this is an assignment to a window["prop"] structure
* BinaryOperator binaryOp = Parent as BinaryOperator;
* if (binaryOp != null && binaryOp.IsAssign
* && m_inBrackets
* && m_func.IsWindowLookup
* && m_args != null)
* {
* // and IF the property is a non-empty constant that isn't currently
* // a global field...
* string propertyName = m_args.SingleConstantArgument;
* if (!string.IsNullOrEmpty(propertyName)
* && Parser.GlobalScope[propertyName] == null)
* {
* // we want to also add it to the global fields so it's not undefined
* Parser.GlobalScope.DeclareField(propertyName, null, 0);
* }
* }
*/
}
//---------------------------------------------------------------------------------------
// ParseLeftHandSideExpression
//
// LeftHandSideExpression :
// PrimaryExpression Accessor |
// 'new' LeftHandSideExpression |
// FunctionExpression
//
// PrimaryExpression :
// 'this' |
// Identifier |
// Literal |
// '(' Expression ')'
//
// FunctionExpression :
// 'function' OptionalFuncName '(' FormalParameterList ')' { FunctionBody }
//
// OptionalFuncName :
// <empty> |
// Identifier
//---------------------------------------------------------------------------------------
private AstNode ParseLeftHandSideExpression(bool isMinus)
{
AstNode ast = null;
bool isFunction = false;
List<Context> newContexts = null;
TryItAgain:
// new expression
while (JSToken.New == m_currentToken.Token)
{
if (null == newContexts)
newContexts = new List<Context>(4);
newContexts.Add(m_currentToken.Clone());
GetNextToken();
}
JSToken token = m_currentToken.Token;
switch (token)
{
// primary expression
case JSToken.Identifier:
ast = new Lookup(m_scanner.GetIdentifier(), m_currentToken.Clone(), this);
break;
case JSToken.ConditionalCommentStart:
// skip past the start to the next token
GetNextToken();
if (m_currentToken.Token == JSToken.PreprocessorConstant)
{
// we have /*@id
ast = new ConstantWrapperPP(m_currentToken.Code, true, m_currentToken.Clone(), this);
GetNextToken();
if (m_currentToken.Token == JSToken.ConditionalCommentEnd)
{
// skip past the closing comment
GetNextToken();
}
else
{
// we ONLY support /*@id@*/ in expressions right now. If there's not
// a closing comment after the ID, then we don't support it.
// throw an error, skip to the end of the comment, then ignore it and start
// looking for the next token.
m_currentToken.HandleError(JSError.ConditionalCompilationTooComplex);
// skip to end of conditional comment
while (m_currentToken.Token != JSToken.EndOfFile && m_currentToken.Token != JSToken.ConditionalCommentEnd)
{
GetNextToken();
}
GetNextToken();
goto TryItAgain;
}
}
else if (m_currentToken.Token == JSToken.ConditionalCommentEnd)
{
// empty conditional comment! Ignore.
GetNextToken();
goto TryItAgain;
}
else
{
// we DON'T have "/*@IDENT". We only support "/*@IDENT @*/", so since this isn't
// and id, throw the error, skip to the end of the comment, and ignore it
// by looping back and looking for the NEXT token.
m_currentToken.HandleError(JSError.ConditionalCompilationTooComplex);
// skip to end of conditional comment
while (m_currentToken.Token != JSToken.EndOfFile && m_currentToken.Token != JSToken.ConditionalCommentEnd)
{
GetNextToken();
}
GetNextToken();
goto TryItAgain;
}
break;
case JSToken.This:
ast = new ThisLiteral(m_currentToken.Clone(), this);
break;
case JSToken.StringLiteral:
ast = new ConstantWrapper(m_scanner.StringLiteral, PrimitiveType.String, m_currentToken.Clone(), this);
break;
case JSToken.IntegerLiteral:
case JSToken.NumericLiteral:
{
Context numericContext = m_currentToken.Clone();
double doubleValue;
if (ConvertNumericLiteralToDouble(m_currentToken.Code, (token == JSToken.IntegerLiteral), out doubleValue))
{
// conversion worked fine
// check for some boundary conditions
if (doubleValue == double.MaxValue)
{
ReportError(JSError.NumericMaximum, numericContext, true);
}
else if (isMinus && -doubleValue == double.MinValue)
{
ReportError(JSError.NumericMinimum, numericContext, true);
}
// create the constant wrapper from the value
ast = new ConstantWrapper(doubleValue, PrimitiveType.Number, numericContext, this);
}
else
{
// check to see if we went overflow
if (double.IsInfinity(doubleValue))
{
ReportError(JSError.NumericOverflow, numericContext, true);
}
// regardless, we're going to create a special constant wrapper
// that simply echos the input as-is
ast = new ConstantWrapper(m_currentToken.Code, PrimitiveType.Other, numericContext, this);
}
break;
}
case JSToken.True:
ast = new ConstantWrapper(true, PrimitiveType.Boolean, m_currentToken.Clone(), this);
break;
case JSToken.False:
ast = new ConstantWrapper(false, PrimitiveType.Boolean, m_currentToken.Clone(), this);
break;
case JSToken.Null:
ast = new ConstantWrapper(null, PrimitiveType.Null, m_currentToken.Clone(), this);
break;
case JSToken.PreprocessorConstant:
ast = new ConstantWrapperPP(m_currentToken.Code, false, m_currentToken.Clone(), this);
break;
case JSToken.DivideAssign:
// normally this token is not allowed on the left-hand side of an expression.
// BUT, this might be the start of a regular expression that begins with an equals sign!
// we need to test to see if we can parse a regular expression, and if not, THEN
// we can fail the parse.
case JSToken.Divide:
// could it be a regexp?
String source = m_scanner.ScanRegExp();
if (source != null)
{
// parse the flags (if any)
String flags = m_scanner.ScanRegExpFlags();
// create the literal
ast = new RegExpLiteral(source, flags, m_currentToken.Clone(), this);
break;
}
goto default;
// expression
case JSToken.LeftParenthesis:
{
// save the current context reference
Context openParenContext = m_currentToken.Clone();
GetNextToken();
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ParenExpressionNoSkipToken);
try
{
// parse an expression
ast = ParseExpression();
// update the expression's context with the context of the open paren
ast.Context.UpdateWith(openParenContext);
if (JSToken.RightParenthesis != m_currentToken.Token)
{
ReportError(JSError.NoRightParenthesis);
}
else
{
// add the closing paren to the expression context
ast.Context.UpdateWith(m_currentToken);
}
}
catch (RecoveryTokenException exc)
{
if (IndexOfToken(NoSkipTokenSet.s_ParenExpressionNoSkipToken, exc) == -1)
throw;
else
ast = exc._partiallyComputedNode;
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ParenExpressionNoSkipToken);
}
if (ast == null) //this can only happen when catching the exception and nothing was sent up by the caller
SkipTokensAndThrow();
}
break;
// array initializer
case JSToken.LeftBracket:
Context listCtx = m_currentToken.Clone();
AstNodeList list = new AstNodeList(m_currentToken.Clone(), this);
GetNextToken();
while (JSToken.RightBracket != m_currentToken.Token)
{
if (JSToken.Comma != m_currentToken.Token)
{
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet);
try
{
list.Append(ParseExpression(true));
if (JSToken.Comma != m_currentToken.Token)
{
if (JSToken.RightBracket != m_currentToken.Token)
ReportError(JSError.NoRightBracket);
break;
}
else
{
// we have a comma -- skip it
GetNextToken();
// if the next token is the closing brackets, then we need to
// add a missing value to the array because we end in a comma and
// we need to keep it for cross-platform compat.
// TECHNICALLY, that puts an extra item into the array for most modern browsers, but not ALL.
if (m_currentToken.Token == JSToken.RightBracket)
{
list.Append(new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this));
}
}
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
list.Append(exc._partiallyComputedNode);
if (IndexOfToken(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet, exc) == -1)
{
listCtx.UpdateWith(CurrentPositionContext());
exc._partiallyComputedNode = new ArrayLiteral(listCtx, this, list);
throw;
}
else
{
if (JSToken.RightBracket == m_currentToken.Token)
break;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ArrayInitNoSkipTokenSet);
}
}
else
{
// comma -- missing array item in the list
list.Append(new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this));
// skip over the comma
GetNextToken();
// if the next token is the closing brace, then we end with a comma -- and we need to
// add ANOTHER missing value to make sure this last comma doesn't get left off.
// TECHNICALLY, that puts an extra item into the array for most modern browsers, but not ALL.
if (m_currentToken.Token == JSToken.RightBracket)
{
list.Append(new ConstantWrapper(Missing.Value, PrimitiveType.Other, m_currentToken.Clone(), this));
}
}
}
listCtx.UpdateWith(m_currentToken);
ast = new ArrayLiteral(listCtx, this, list);
break;
// object initializer
case JSToken.LeftCurly:
Context objCtx = m_currentToken.Clone();
GetNextToken();
// we're going to keep the keys and values in separate lists, but make sure
// that the indexes correlate (keyList[n] is associated with valueList[n])
List<ObjectLiteralField> keyList = new List<ObjectLiteralField>();
List<AstNode> valueList = new List<AstNode>();
if (JSToken.RightCurly != m_currentToken.Token)
{
for (; ; )
{
ObjectLiteralField field = null;
AstNode value = null;
bool getterSetter = false;
string ident;
switch (m_currentToken.Token)
{
case JSToken.Identifier:
field = new ObjectLiteralField(m_scanner.GetIdentifier(), PrimitiveType.String, m_currentToken.Clone(), this);
break;
case JSToken.StringLiteral:
field = new ObjectLiteralField(m_scanner.StringLiteral, PrimitiveType.String, m_currentToken.Clone(), this);
break;
case JSToken.IntegerLiteral:
case JSToken.NumericLiteral:
{
double doubleValue;
if (ConvertNumericLiteralToDouble(m_currentToken.Code, (m_currentToken.Token == JSToken.IntegerLiteral), out doubleValue))
{
// conversion worked fine
field = new ObjectLiteralField(
doubleValue,
PrimitiveType.Number,
m_currentToken.Clone(),
this
);
}
else
{
// something went wrong and we're not sure the string representation in the source is
// going to convert to a numeric value well
if (double.IsInfinity(doubleValue))
{
ReportError(JSError.NumericOverflow, m_currentToken.Clone(), true);
}
// use the source as the field name, not the numeric value
field = new ObjectLiteralField(
m_currentToken.Code,
PrimitiveType.Other,
m_currentToken.Clone(),
this);
}
break;
}
case JSToken.Get:
case JSToken.Set:
if (m_scanner.PeekToken() == JSToken.Colon)
{
// the field is either "get" or "set" and isn't the special Mozilla getter/setter
field = new ObjectLiteralField(m_currentToken.Code, PrimitiveType.String, m_currentToken.Clone(), this);
}
else
{
// ecma-script get/set property construct
getterSetter = true;
bool isGet = (m_currentToken.Token == JSToken.Get);
value = ParseFunction(
(JSToken.Get == m_currentToken.Token ? FunctionType.Getter : FunctionType.Setter),
m_currentToken.Clone()
);
FunctionObject funcExpr = value as FunctionObject;
if (funcExpr != null)
{
// getter/setter is just the literal name with a get/set flag
field = new GetterSetter(
funcExpr.Name,
isGet,
funcExpr.IdContext.Clone(),
this
);
}
else
{
ReportError(JSError.FunctionExpressionExpected);
}
}
break;
default:
// NOT: identifier, string, number, or getter/setter.
// see if it's a token that COULD be an identifier.
ident = JSKeyword.CanBeIdentifier(m_currentToken.Token);
if (ident != null)
{
// don't throw a warning -- it's okay to have a keyword that
// can be an identifier here.
field = new ObjectLiteralField(ident, PrimitiveType.String, m_currentToken.Clone(), this);
}
else
{
ReportError(JSError.NoMemberIdentifier);
field = new ObjectLiteralField("_#Missing_Field#_" + s_cDummyName++, PrimitiveType.String, CurrentPositionContext(), this);
}
break;
}
if (field != null)
{
if (!getterSetter)
{
GetNextToken();
}
m_noSkipTokenSet.Add(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet);
try
{
if (!getterSetter)
{
// get the value
if (JSToken.Colon != m_currentToken.Token)
{
ReportError(JSError.NoColon, true);
value = ParseExpression(true);
}
else
{
GetNextToken();
value = ParseExpression(true);
}
}
// put the pair into the list of fields
keyList.Add(field);
valueList.Add(value);
if (JSToken.RightCurly == m_currentToken.Token)
break;
else
{
if (JSToken.Comma == m_currentToken.Token)
{
// skip the comma
GetNextToken();
// if the next token is the right-curly brace, then we ended
// the list with a comma, which is perfectly fine
if (m_currentToken.Token == JSToken.RightCurly)
{
break;
}
}
else
{
if (m_scanner.GotEndOfLine)
{
ReportError(JSError.NoRightCurly);
}
else
ReportError(JSError.NoComma, true);
SkipTokensAndThrow();
}
}
}
catch (RecoveryTokenException exc)
{
if (exc._partiallyComputedNode != null)
{
// the problem was in ParseExpression trying to determine value
value = exc._partiallyComputedNode;
keyList.Add(field);
valueList.Add(value);
}
if (IndexOfToken(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet, exc) == -1)
{
exc._partiallyComputedNode = new ObjectLiteral(objCtx, this, keyList.ToArray(), valueList.ToArray());
throw;
}
else
{
if (JSToken.Comma == m_currentToken.Token)
GetNextToken();
if (JSToken.RightCurly == m_currentToken.Token)
break;
}
}
finally
{
m_noSkipTokenSet.Remove(NoSkipTokenSet.s_ObjectInitNoSkipTokenSet);
}
}
}
}
objCtx.UpdateWith(m_currentToken);
ast = new ObjectLiteral(objCtx, this, keyList.ToArray(), valueList.ToArray());
break;
// function expression
case JSToken.Function:
ast = ParseFunction(FunctionType.Expression, m_currentToken.Clone());
isFunction = true;
break;
case JSToken.AspNetBlock:
ast = ParseAspNetBlock(consumeSemicolonIfPossible: false);
break;
default:
string identifier = JSKeyword.CanBeIdentifier(m_currentToken.Token);
if (null != identifier)
{
ast = new Lookup(identifier, m_currentToken.Clone(), this);
}
else
{
ReportError(JSError.ExpressionExpected);
SkipTokensAndThrow();
}
break;
}
// can be a CallExpression, that is, followed by '.' or '(' or '['
if (!isFunction)
GetNextToken();
return MemberExpression(ast, newContexts);
}
public override void Visit(CallNode node)
{
if (node != null)
{
// see if this is a member (we'll need it for a couple checks)
Member member = node.Function as Member;
if (m_parser.Settings.StripDebugStatements
&& m_parser.Settings.IsModificationAllowed(TreeModifications.StripDebugStatements))
{
// if this is a member, and it's a debugger object, and it's a constructor....
if (member != null && member.IsDebuggerStatement && node.IsConstructor)
{
// we need to replace our debugger object with a generic Object
node.ReplaceChild(node.Function, new Lookup("Object", node.Function.Context, m_parser));
// and make sure the node list is empty
if (node.Arguments != null && node.Arguments.Count > 0)
{
node.ReplaceChild(node.Arguments, new AstNodeList(node.Arguments.Context, m_parser));
}
}
}
// if this is a constructor and we want to collapse
// some of them to literals...
if (node.IsConstructor && m_parser.Settings.CollapseToLiteral)
{
// see if this is a lookup, and if so, if it's pointing to one
// of the two constructors we want to collapse
Lookup lookup = node.Function as Lookup;
if (lookup != null)
{
if (lookup.Name == "Object"
&& m_parser.Settings.IsModificationAllowed(TreeModifications.NewObjectToObjectLiteral))
{
// no arguments -- the Object constructor with no arguments is the exact same as an empty
// object literal
if (node.Arguments == null || node.Arguments.Count == 0)
{
// replace our node with an object literal
ObjectLiteral objLiteral = new ObjectLiteral(node.Context, m_parser, null, null);
if (node.Parent.ReplaceChild(node, objLiteral))
{
// and bail now. No need to recurse -- it's an empty literal
return;
}
}
else if (node.Arguments.Count == 1)
{
// one argument
// check to see if it's an object literal.
ObjectLiteral objectLiteral = node.Arguments[0] as ObjectLiteral;
if (objectLiteral != null)
{
// the Object constructor with an argument that is a JavaScript object merely returns the
// argument. Since the argument is an object literal, it is by definition a JavaScript object
// and therefore we can replace the constructor call with the object literal
node.Parent.ReplaceChild(node, objectLiteral);
// don't forget to recurse the object now
objectLiteral.Accept(this);
// and then bail -- we don't want to process this call
// operation any more; we've gotten rid of it
return;
}
}
}
else if (lookup.Name == "Array"
&& m_parser.Settings.IsModificationAllowed(TreeModifications.NewArrayToArrayLiteral))
{
// Array is trickier.
// If there are no arguments, then just use [].
// if there are multiple arguments, then use [arg0,arg1...argN].
// but if there is one argument and it's numeric, we can't crunch it.
// also can't crunch if it's a function call or a member or something, since we won't
// KNOW whether or not it's numeric.
//
// so first see if it even is a single-argument constant wrapper.
ConstantWrapper constWrapper = (node.Arguments != null && node.Arguments.Count == 1
? node.Arguments[0] as ConstantWrapper
: null);
// if the argument count is not one, then we crunch.
// if the argument count IS one, we only crunch if we have a constant wrapper,
// AND it's not numeric.
if (node.Arguments == null
|| node.Arguments.Count != 1
|| (constWrapper != null && !constWrapper.IsNumericLiteral))
{
// create the new array literal object
ArrayLiteral arrayLiteral = new ArrayLiteral(node.Context, m_parser, node.Arguments);
// replace ourself within our parent
if (node.Parent.ReplaceChild(node, arrayLiteral))
{
// recurse
arrayLiteral.Accept(this);
// and bail -- we don't want to recurse this node any more
return;
}
}
}
}
}
// if we are replacing resource references with strings generated from resource files
// and this is a brackets call: lookup[args]
ResourceStrings resourceStrings = m_parser.ResourceStrings;
if (node.InBrackets && resourceStrings != null && resourceStrings.Count > 0)
{
// see if the root object is a lookup that corresponds to the
// global value (not a local field) for our resource object
// (same name)
Lookup rootLookup = node.Function as Lookup;
if (rootLookup != null
&& rootLookup.LocalField == null
&& string.CompareOrdinal(rootLookup.Name, resourceStrings.Name) == 0)
{
// we're going to replace this node with a string constant wrapper
// but first we need to make sure that this is a valid lookup.
// if the parameter contains anything that would vary at run-time,
// then we need to throw an error.
// the parser will always have either one or zero nodes in the arguments
// arg list. We're not interested in zero args, so just make sure there is one
if (node.Arguments.Count == 1)
{
// must be a constant wrapper
ConstantWrapper argConstant = node.Arguments[0] as ConstantWrapper;
if (argConstant != null)
{
string resourceName = argConstant.Value.ToString();
// get the localized string from the resources object
ConstantWrapper resourceLiteral = new ConstantWrapper(
resourceStrings[resourceName],
PrimitiveType.String,
node.Context,
m_parser);
// replace this node with localized string, analyze it, and bail
// so we don't anaylze the tree we just replaced
node.Parent.ReplaceChild(node, resourceLiteral);
resourceLiteral.Accept(this);
return;
}
else
{
// error! must be a constant
node.Context.HandleError(
JSError.ResourceReferenceMustBeConstant,
true);
}
}
else
{
// error! can only be a single constant argument to the string resource object.
// the parser will only have zero or one arguments, so this must be zero
// (since the parser won't pass multiple args to a [] operator)
node.Context.HandleError(
JSError.ResourceReferenceMustBeConstant,
true);
}
}
}
// and finally, if this is a backets call and the argument is a constantwrapper that can
// be an identifier, just change us to a member node: obj["prop"] to obj.prop.
// but ONLY if the string value is "safe" to be an identifier. Even though the ECMA-262
// spec says certain Unicode categories are okay, in practice the various major browsers
// all seem to have problems with certain characters in identifiers. Rather than risking
// some browsers breaking when we change this syntax, don't do it for those "danger" categories.
if (node.InBrackets && node.Arguments != null)
{
// see if there is a single, constant argument
string argText = node.Arguments.SingleConstantArgument;
if (argText != null)
{
// see if we want to replace the name
string newName;
if (m_parser.Settings.HasRenamePairs && m_parser.Settings.ManualRenamesProperties
&& m_parser.Settings.IsModificationAllowed(TreeModifications.PropertyRenaming)
&& !string.IsNullOrEmpty(newName = m_parser.Settings.GetNewName(argText)))
{
// yes -- we are going to replace the name, either as a string literal, or by converting
// to a member-dot operation.
// See if we can't turn it into a dot-operator. If we can't, then we just want to replace the operator with
// a new constant wrapper. Otherwise we'll just replace the operator with a new constant wrapper.
if (m_parser.Settings.IsModificationAllowed(TreeModifications.BracketMemberToDotMember)
&& JSScanner.IsSafeIdentifier(newName)
&& !JSScanner.IsKeyword(newName, node.EnclosingScope.UseStrict))
{
// the new name is safe to convert to a member-dot operator.
// but we don't want to convert the node to the NEW name, because we still need to Analyze the
// new member node -- and it might convert the new name to something else. So instead we're
// just going to convert this existing string to a member node WITH THE OLD STRING,
// and THEN analyze it (which will convert the old string to newName)
Member replacementMember = new Member(node.Context, m_parser, node.Function, argText, node.Arguments[0].Context);
node.Parent.ReplaceChild(node, replacementMember);
// this analyze call will convert the old-name member to the newName value
replacementMember.Accept(this);
return;
}
else
{
// nope; can't convert to a dot-operator.
// we're just going to replace the first argument with a new string literal
// and continue along our merry way.
node.Arguments.ReplaceChild(node.Arguments[0], new ConstantWrapper(newName, PrimitiveType.String, node.Arguments[0].Context, m_parser));
}
}
else if (m_parser.Settings.IsModificationAllowed(TreeModifications.BracketMemberToDotMember)
&& JSScanner.IsSafeIdentifier(argText)
&& !JSScanner.IsKeyword(argText, node.EnclosingScope.UseStrict))
{
// not a replacement, but the string literal is a safe identifier. So we will
// replace this call node with a Member-dot operation
Member replacementMember = new Member(node.Context, m_parser, node.Function, argText, node.Arguments[0].Context);
node.Parent.ReplaceChild(node, replacementMember);
replacementMember.Accept(this);
return;
}
}
}
// call the base class to recurse
base.Visit(node);
// might have changed
member = node.Function as Member;
// call this AFTER recursing to give the fields a chance to resolve, because we only
// want to make this replacement if we are working on the global Date object.
if (!node.InBrackets && !node.IsConstructor
&& (node.Arguments == null || node.Arguments.Count == 0)
&& member != null && string.CompareOrdinal(member.Name, "getTime") == 0
&& m_parser.Settings.IsModificationAllowed(TreeModifications.DateGetTimeToUnaryPlus))
{
// this is not a constructor and it's not a brackets call, and there are no arguments.
// if the function is a member operation to "getTime" and the object of the member is a
// constructor call to the global "Date" object (not a local), then we want to replace the call
// with a unary plus on the Date constructor. Converting to numeric type is the same as
// calling getTime, so it's the equivalent with much fewer bytes.
CallNode dateConstructor = member.Root as CallNode;
if (dateConstructor != null
&& dateConstructor.IsConstructor)
{
// lookup for the predifined (not local) "Date" field
Lookup lookup = dateConstructor.Function as Lookup;
if (lookup != null && string.CompareOrdinal(lookup.Name, "Date") == 0
&& lookup.LocalField == null)
{
// this is in the pattern: (new Date()).getTime()
// we want to replace it with +new Date
// use the same date constructor node as the operand
NumericUnary unary = new NumericUnary(node.Context, m_parser, dateConstructor, JSToken.Plus);
// replace us (the call to the getTime method) with this unary operator
node.Parent.ReplaceChild(node, unary);
// don't need to recurse on the unary operator. The operand has already
// been analyzed when we recursed, and the unary operator wouldn't do anything
// special anyway (since the operand is not a numeric constant)
}
}
}
else
{
var isEval = false;
var lookup = node.Function as Lookup;
if (lookup != null
&& string.CompareOrdinal(lookup.Name, "eval") == 0
&& lookup.VariableField is JSPredefinedField)
{
// call to predefined eval function
isEval = true;
}
else if (member != null && string.CompareOrdinal(member.Name, "eval") == 0)
{
// if this is a window.eval call, then we need to mark this scope as unknown just as
// we would if this was a regular eval call.
// (unless, of course, the parser settings say evals are safe)
// call AFTER recursing so we know the left-hand side properties have had a chance to
// lookup their fields to see if they are local or global
if (member.LeftHandSide.IsWindowLookup)
{
// this is a call to window.eval()
isEval = true;
}
}
else
{
CallNode callNode = node.Function as CallNode;
if (callNode != null
&& callNode.InBrackets
&& callNode.LeftHandSide.IsWindowLookup
&& callNode.Arguments.IsSingleConstantArgument("eval"))
{
// this is a call to window["eval"]
isEval = true;
}
}
if (isEval)
{
if (m_parser.Settings.EvalTreatment != EvalTreatment.Ignore)
{
// mark this scope as unknown so we don't crunch out locals
// we might reference in the eval at runtime
ScopeStack.Peek().IsKnownAtCompileTime = false;
}
}
}
}
}
public override void Visit(ObjectLiteral node)
{
if (node != null)
{
// recurse
base.Visit(node);
if (ScopeStack.Peek().UseStrict)
{
// now strict-mode checks
// go through all property names and make sure there are no duplicates.
// use a map to remember which ones we already have.
var nameMap = new Dictionary<string, string>(node.Count);
for (var ndx = 0; ndx < node.Keys.Count; ++ndx)
{
// get the name and type of this property
var propertyName = node.Keys[ndx].ToString();
var propertyType = GetPropertyType(node.Values[ndx] as FunctionObject);
// key name is the name plus the type. Can't just use the name because
// get and set will both have the same name (but different types)
var keyName = propertyName + propertyType;
string mappedType;
if (propertyType == "data")
{
// can't have another data, get, or set
if (nameMap.TryGetValue(keyName, out mappedType)
|| nameMap.TryGetValue(propertyName + "get", out mappedType)
|| nameMap.TryGetValue(propertyName + "set", out mappedType))
{
// throw the error
node.Keys[ndx].Context.HandleError(JSError.StrictModeDuplicateProperty, true);
// if the mapped type isn't data, then we can add this data name/type to the map
// because that means the first tryget failed and we don't have a data already
if (mappedType != propertyType)
{
nameMap.Add(keyName, propertyType);
}
}
else
{
// not in the map at all. Add it now.
nameMap.Add(keyName, propertyType);
}
}
else
{
// get can have a set, but can't have a data or another get
// set can have a get, but can't have a data or another set
if (nameMap.TryGetValue(keyName, out mappedType)
|| nameMap.TryGetValue(propertyName + "data", out mappedType))
{
// throw the error
node.Keys[ndx].Context.HandleError(JSError.StrictModeDuplicateProperty, true);
// if the mapped type isn't data, then we can add this data name/type to the map
if (mappedType != propertyType)
{
nameMap.Add(keyName, propertyType);
}
}
else
{
// not in the map at all - add it now
nameMap.Add(keyName, propertyType);
}
}
}
}
}
}
public void Visit(ObjectLiteral node)
{
// recurse the properties
node.IfNotNull(n => n.Properties.ForEach(p => p.Accept(this)));
}
public override void Visit(ObjectLiteral node)
{
// same logic for most nodes
TypicalHandler(node);
}