/// <summary>
/// Determine if the script is a javascript function and not an expression.
/// </summary>
/// <param name="script">Script to evaluate.</param>
/// <param name="retry">Whether it should retry by wrapping the code in parenthesis.</param>
/// <param name="checkExpression">Checks whether the function could be a function expression.</param>
/// <returns>Whether the script is a function or not.</returns>
public static bool IsJavascriptFunction(this string script, bool retry = true, bool checkExpression = false)
{
try
{
var parser = new JavaScriptParser(script);
var program = parser.ParseScript();
if (program.Body.Count > 0)
{
return
((program.Body[0] is ExpressionStatement expression && (
expression.Expression.Type == Nodes.ArrowFunctionExpression ||
(checkExpression && expression.Expression.Type == Nodes.FunctionExpression))) ||
program.Body[0] is FunctionDeclaration);
}
return(false);
}
catch (ParserException)
{
if (retry)
{
return(IsJavascriptFunction($"({script})", false, true));
}
return(true);
}
}
public void ProgramShouldNotBeStrict()
{
var parser = new JavaScriptParser("function p() {}");
var program = parser.ParseScript();
Assert.False(program.Strict);
}
public void ShouldParseRegularExpression(string regexp)
{
var parser = new JavaScriptParser(@"var O = " + regexp);
var program = parser.ParseScript();
Assert.NotNull(program);
}
/// <summary>
/// Determine if the script is a javascript function and not an expression.
/// </summary>
/// <param name="script">Script to evaluate.</param>
/// <returns>Whether the script is a function or not.</returns>
public static bool IsJavascriptFunction(this string script)
{
try
{
var parser = new JavaScriptParser(script);
var program = parser.ParseScript();
if (program.Body.Count > 0)
{
return
((program.Body[0] is ExpressionStatement expression && expression.Expression.Type == Nodes.ArrowFunctionExpression) ||
program.Body[0] is FunctionDeclaration);
}
return(false);
}
catch (ParserException)
{
// Retry using parenthesis
var parser = new JavaScriptParser($"({script})");
var program = parser.ParseScript();
if (program.Body.Count > 0)
{
return
(program.Body.Count > 0 &&
program.Body[0] is ExpressionStatement expression &&
expression.Expression.Type == Nodes.FunctionExpression);
}
return(false);
}
}
static MethodDefinition CreateConstructorMethodDefinition(string source)
{
var parser = new JavaScriptParser(source);
var script = parser.ParseScript();
return((MethodDefinition)script.Body[0].ChildNodes[2].ChildNodes[0]);
}
public void Setup()
{
var code = File.ReadAllText("3rdparty/angular-1.7.9.js");
var parser = new JavaScriptParser(code);
_script = parser.ParseScript();
}
public void HoistingScopeShouldWork()
{
var parser = new JavaScriptParser(@"
function p() {}
var x;");
var program = parser.ParseScript();
}
public void ProgramShouldBeStrict()
{
var parser = new JavaScriptParser("'use strict'; function p() {}");
var program = parser.ParseScript();
Assert.True(program.Strict);
}
public void FunctionShouldNotBeStrict()
{
var parser = new JavaScriptParser("function p() {}");
var program = parser.ParseScript();
var function = program.Body.First().As <FunctionDeclaration>();
Assert.False(function.Strict);
}
public void ThrowsErrorForDuplicateProto()
{
var parser = new JavaScriptParser("if({ __proto__: [], __proto__: [] } instanceof Array) {}", new ParserOptions {
Tolerant = false
});
Assert.Throws <ParserException>(() => parser.ParseScript());
}
public void AllowsSingleProto()
{
var parser = new JavaScriptParser("if({ __proto__: [] } instanceof Array) {}", new ParserOptions {
Tolerant = false
});
parser.ParseScript();
}
public void FunctionShouldBeStrictInProgramStrict()
{
var parser = new JavaScriptParser("'use strict'; function p() {}");
var program = parser.ParseScript();
var function = program.Body.Skip(1).First().As <FunctionDeclaration>();
Assert.True(function.Strict);
}
public void FunctionShouldBeStrict()
{
var parser = new JavaScriptParser("function p() {'use strict'; return false;}");
var program = parser.ParseScript();
var function = program.Body.First().As <FunctionDeclaration>();
Assert.True(function.Strict);
}
public void ParseProgram()
{
for (int i = 0; i < N; ++i)
{
var parser = new JavaScriptParser(Script);
parser.ParseScript();
}
}
private static void Parse(string source, TextWriter output)
{
var parser = new JavaScriptParser(source);
var program = parser.ParseScript();
program.WriteJson(output);
Console.WriteLine();
}
private Engine BuildTestExecutor(Test262File file)
{
var engine = new Engine(cfg =>
{
var relativePath = Path.GetDirectoryName(file.FileName);
cfg.EnableModules(new Test262ModuleLoader(State.Test262Stream.Options.FileSystem, relativePath));
});
engine.Execute(State.Sources["assert.js"]);
engine.Execute(State.Sources["sta.js"]);
engine.SetValue("print",
new ClrFunctionInstance(engine, "print", (thisObj, args) => TypeConverter.ToString(args.At(0))));
var o = engine.Realm.Intrinsics.Object.Construct(Arguments.Empty);
o.FastSetProperty("evalScript", new PropertyDescriptor(new ClrFunctionInstance(engine, "evalScript",
(thisObj, args) =>
{
if (args.Length > 1)
{
throw new Exception("only script parsing supported");
}
var options = new ParserOptions {
AdaptRegexp = true, Tolerant = false
};
var parser = new JavaScriptParser(args.At(0).AsString(), options);
var script = parser.ParseScript();
return(engine.Evaluate(script));
}), true, true, true));
o.FastSetProperty("createRealm", new PropertyDescriptor(new ClrFunctionInstance(engine, "createRealm",
(thisObj, args) =>
{
var realm = engine._host.CreateRealm();
realm.GlobalObject.Set("global", realm.GlobalObject);
return(realm.GlobalObject);
}), true, true, true));
o.FastSetProperty("detachArrayBuffer", new PropertyDescriptor(new ClrFunctionInstance(engine, "detachArrayBuffer",
(thisObj, args) =>
{
var buffer = (ArrayBufferInstance)args.At(0);
buffer.DetachArrayBuffer();
return(JsValue.Undefined);
}), true, true, true));
engine.SetValue("$262", o);
foreach (var include in file.Includes)
{
engine.Execute(State.Sources[include]);
}
return(engine);
}
public void CanVisitForWithNoTest()
{
var parser = new JavaScriptParser(@"for (var a = []; ; ) { }");
var program = parser.ParseScript();
var visitor = new AstVisitor();
visitor.Visit(program);
}
public void CanVisitForOfStatement()
{
var parser = new JavaScriptParser(@"for (var elem of list) { }");
var program = parser.ParseScript();
var visitor = new AstVisitor();
visitor.Visit(program);
}
public void CanVisitIfWithNoElse()
{
var parser = new JavaScriptParser("if (true) { p(); }");
var program = parser.ParseScript();
var visitor = new AstVisitor();
visitor.Visit(program);
}
public void LabelSetShouldPointToStatement()
{
var parser = new JavaScriptParser("here: Hello();");
var program = parser.ParseScript();
var labeledStatement = program.Body.First().As <LabeledStatement>();
var body = labeledStatement.Body;
Assert.Equal(labeledStatement.Label, body.LabelSet);
}
public static Context CreateInstance(string js)
{
var cc = new Context();
var parser = new JavaScriptParser(js, new ParserOptions {
Loc = true
});
cc.Script = parser.ParseScript(true);
return(cc);
}
public void CommentsAreParsed()
{
int count = 0;
Action <INode> action = node => count++;
var parser = new JavaScriptParser("// this is a comment", new ParserOptions(), action);
parser.ParseScript();
Assert.Equal(1, count);
}
public void ShouldParseLocation()
{
var options = new ParserOptions
{
Loc = true
};
var parser = new JavaScriptParser("// End on second line\r\n", options);
var program = parser.ParseScript();
}
public void HoistingScopeShouldWork()
{
var parser = new JavaScriptParser(@"
function p() {}
var x;");
var program = parser.ParseScript();
Assert.NotEmpty(program.HoistingScope.FunctionDeclarations);
Assert.NotEmpty(program.HoistingScope.VariableDeclarations);
}
private Script BuildAST()
{
var customParserOptions = new ParserOptions();
customParserOptions.Loc = true;
customParserOptions.Range = true;
var parser = new JavaScriptParser(code, customParserOptions);
var program = parser.ParseScript();
return(program);
}
public void ParsesValidForAwaitLoops(string code)
{
var errorHandler = new CollectingErrorHandler();
var parser = new JavaScriptParser(code, new ParserOptions {
Tolerant = true, ErrorHandler = errorHandler
});
parser.ParseScript();
Assert.False(errorHandler.Errors.Any());
}
private static void ExecuteTest(JavaScriptParser parser, Test262File file)
{
if (file.Type == ProgramType.Script)
{
parser.ParseScript(file.Strict);
}
else
{
parser.ParseModule();
}
}
public void ShouldParseBundleJs()
{
// It contains very diverse unicode regular expression
var path = Path.Combine(Fixtures.GetFixturesPath(), "Fixtures", "3rdparty", "bundle.js");
var source = File.ReadAllText(path);
var parser = new JavaScriptParser(source, new ParserOptions {
AdaptRegexp = true
});
parser.ParseScript();
}
/// <summary>
/// Determin if the script is a javascript function and not an expression.
/// </summary>
/// <param name="script">Script to evaluate.</param>
/// <returns>Whether the script is a function or not.</returns>
public static bool IsJavascriptFunction(this string script)
{
var parser = new JavaScriptParser(script);
var program = parser.ParseScript();
if (program.Body.Count > 0 && program.Body[0] is ExpressionStatement expression)
{
return(expression.Expression.Type == Nodes.ArrowFunctionExpression);
}
return(false);
}
public Script Parse(string script)
{
var cacheKey = $"{typeof(Parser)}_Script_{script}";
return(cache.GetOrCreate(cacheKey, entry =>
{
entry.AbsoluteExpirationRelativeToNow = CacheDuration;
var parser = new JavaScriptParser(script, DefaultParserOptions);
return parser.ParseScript();
}));
}
