private AstRoot parse(String string, boolean jsdoc) { CompilerEnvirons environment = new CompilerEnvirons(); TestErrorReporter testErrorReporter = new TestErrorReporter(null, null); environment.setErrorReporter(testErrorReporter); environment.setRecordingComments(true); environment.setRecordingLocalJsDocComments(jsdoc); Parser p = new Parser(environment, testErrorReporter); AstRoot script = p.parse(string, null, 0); assertTrue(testErrorReporter.hasEncounteredAllErrors()); assertTrue(testErrorReporter.hasEncounteredAllWarnings()); return script; }
private AstRoot parseAsReader(String string) throws IOException { CompilerEnvirons environment = new CompilerEnvirons(); TestErrorReporter testErrorReporter = new TestErrorReporter(null, null); environment.setErrorReporter(testErrorReporter); environment.setRecordingComments(true); environment.setRecordingLocalJsDocComments(true); Parser p = new Parser(environment, testErrorReporter); AstRoot script = p.parse(new StringReader(string), null, 0); assertTrue(testErrorReporter.hasEncounteredAllErrors()); assertTrue(testErrorReporter.hasEncounteredAllWarnings()); return script; }
@Test public void testNodeReplacementInWhileLoopWithBrackets() throws IOException { String script = "var o = {\n" + " _x: 123, \n" + " get x() {\n" + " return this._x;\n" + " }\n" + ", \n" + " set x(value) {\n" + " this._x = value;\n" + " }\n" + "};\n"; Parser parser = new Parser(environment); AstRoot astRoot = parser.parse(new StringReader(script), null, 1); assertEquals(script, astRoot.toSource()); }
/** * Compiles {@code source} and returns the transformed and optimized * {@link ScriptNode} */ protected ScriptNode compile(CharSequence source) { final String mainMethodClassName = "Main"; final String scriptClassName = "Main"; CompilerEnvirons compilerEnv = new CompilerEnvirons(); compilerEnv.initFromContext(cx); Parser p = new Parser(compilerEnv); AstRoot ast = p.parse(source.toString(), "<eval>", 1); IRFactory irf = new IRFactory(compilerEnv); ScriptNode tree = irf.transformTree(ast); Codegen codegen = new Codegen(); codegen.setMainMethodClass(mainMethodClassName); codegen.compileToClassFile(compilerEnv, scriptClassName, tree, tree.getEncodedSource(), false); return tree; }
/** * Compiles {@code source} and returns the transformed and optimized * {@link ScriptNode} */ protected ScriptNode compile(CharSequence source) { final String mainMethodClassName = "Main"; final String scriptClassName = "Main"; CompilerEnvirons compilerEnv = new CompilerEnvirons(); compilerEnv.initFromContext(cx); ErrorReporter compilationErrorReporter = compilerEnv .getErrorReporter(); Parser p = new Parser(compilerEnv, compilationErrorReporter); AstRoot ast = p.parse(source.toString(), "<eval>", 1); IRFactory irf = new IRFactory(compilerEnv); ScriptNode tree = irf.transformTree(ast); Codegen codegen = new Codegen(); codegen.setMainMethodClass(mainMethodClassName); codegen.compileToClassFile(compilerEnv, scriptClassName, tree, tree.getEncodedSource(), false); return tree; }
/** * @return a tree representation of the parsed JavaScript file * @throws IOException */ public ScriptOrFnNode parse() throws IOException { if (nodeTree == null) { Reader reader = new FileReader(jsFile); CompilerEnvirons compilerEnv = new CompilerEnvirons(); ErrorReporter errorReporter = compilerEnv.getErrorReporter(); Parser parser = new Parser(compilerEnv, errorReporter); String sourceURI; try { sourceURI = jsFile.getCanonicalPath(); } catch (IOException e) { sourceURI = jsFile.toString(); } nodeTree = parser.parse(reader, sourceURI, 1); } return nodeTree; }
private static String explainErrors(JSEnvironment env, String sourceCode) { AstRoot root = new Parser().parse(sourceCode, "", 1); SatSolver sat = new Sat4J(); SJSTypeTheory theory = new SJSTypeTheory(env, null, root); List<Integer> hard = new ArrayList<>(); List<Integer> soft = new ArrayList<>(); List<ITypeConstraint> constraints = theory.getConstraints(); for (int i = 0; i < constraints.size(); ++i) { (theory.hackyGenerator().hasExplanation(constraints.get(i)) ? soft : hard).add(i); } Pair<TypeAssignment, Collection<Integer>> result = TheorySolver.solve( theory, new SatFixingSetFinder<>(sat), hard, soft); ConstraintGenerator g = theory.hackyGenerator(); StringBuilder buf = new StringBuilder(); for (int broken : result.getRight()) { ITypeConstraint c = theory.hackyConstraintAccess().get(broken); ByteArrayOutputStream stream = new ByteArrayOutputStream(); g.explainFailure(c, result.getLeft()).prettyprint(new PrintStream(stream)); buf.append(stream.toString()); } return buf.toString(); }
/** * Scan the given file for class definitions and accumulate dependencies. */ private void scan(final File source) throws IOException { log.debug("Scanning: " + source); ErrorReporter errorReporter = new LogErrorReporter(log); CompilerEnvirons env = new CompilerEnvirons(); env.setErrorReporter(errorReporter); Parser parser = new Parser(env, errorReporter); Reader reader = new BufferedReader(new FileReader(source)); try { AstRoot root = parser.parse(reader, source.getAbsolutePath(), 0); DependencyAccumulator visitor = new DependencyAccumulator(source); root.visit(visitor); // complain if no def was found in this source if (visitor.current == null) { log.warn("No class definition was found while processing: " + source); } } finally { reader.close(); } }
@Override public Bundle parse(InputStream inStream) throws IOException { LinkedHashMap<String, String> resultMap = null; Bundle result = new Bundle(); try (InputStreamReader reader = new InputStreamReader(new BomInputStream(inStream), "UTF-8")) { AstRoot root = new Parser().parse(reader, null, 1); KeyValueVisitor visitor = new KeyValueVisitor(); root.visitAll(visitor); resultMap = visitor.elements; int sequenceNum = 1; for (Entry<String, String> entry : resultMap.entrySet()) { result.addResourceString(entry.getKey(), entry.getValue(), sequenceNum++); } } catch (Exception e) { throw new IllegalResourceFormatException(e); } return result; }
/** * * @param fileName * @param staticMethods * @param staticFields * @return * @throws FileNotFoundException * @throws IOException */ Collection<JsFile> parseFile(final String fileName, final List<JsMethod> staticMethods, final Map<String, JsElement> staticFields) throws FileNotFoundException, IOException { try (final Reader reader = new FileReader(fileName)) { final CompilerEnvirons env = new CompilerEnvirons(); env.setRecordingLocalJsDocComments(true); env.setAllowSharpComments(true); env.setRecordingComments(true); final AstRoot node = new Parser(env).parse(reader, fileName, 1); final JavaScriptFileParser parser = new JavaScriptFileParser(fileName); node.visitAll(parser); staticMethods.addAll(parser.getStaticMethods()); staticFields.putAll(parser.getConsts()); return parser.getFiles(); } }
/** * * @param expr * @param objectName * @return */ private static String getReferencedScriptObject( String expr, String objectName ) { if ( expr == null ) return null; try { Context cx = Context.enter( ); CompilerEnvirons ce = new CompilerEnvirons( ); Parser p = new Parser( ce, cx.getErrorReporter( ) ); AstRoot tree = p.parse( expr, null, 0 ); IRFactory ir = new IRFactory( ce ); ScriptNode script = ir.transformTree( tree ); return getScriptObjectName( script, objectName ); } finally { Context.exit( ); } }
/** * * @param expr * @param objectName * @return */ public static String getReferencedScriptObject( String expr, String objectName ) { if ( expr == null ) return null; try { Context cx = Context.enter( ); CompilerEnvirons ce = new CompilerEnvirons( ); Parser p = new Parser( ce, cx.getErrorReporter( ) ); AstRoot tree = p.parse( expr, null, 0 ); Node root = new IRFactory( ce).transformTree(tree); return getScriptObjectName( root, objectName ); } catch( Exception ex ) { return null; } finally { Context.exit( ); } }
public void parseScript(String scriptText, TypeDeclarationOptions options) { if(scriptText != null && scriptText.length() > 0) { CompilerEnvirons env = JavaScriptParser.createCompilerEnvironment(new JavaScriptParser.JSErrorReporter(), provider.getLanguageSupport()); Parser parser = new Parser(env); StringReader r = new StringReader(scriptText); try { AstRoot root = parser.parse(r, null, 0); CodeBlock block = provider.iterateAstRoot(root, preProcessingCompletions, "", Integer.MAX_VALUE, options); provider.recursivelyAddLocalVars(preProcessingCompletions, block, 0, null, false, true); } catch(IOException io) { //ignore this } } }
/** * Compiles Text and resolves the type. * e.g * "Hello World".length; //resolve as a Number * * @param text to compile and resolve */ @Override public JavaScriptType compileText(String text) throws IOException { CompilerEnvirons env = JavaScriptParser.createCompilerEnvironment(new JavaScriptParser.JSErrorReporter(), provider.getLanguageSupport()); String parseText = JavaScriptHelper.removeLastDotFromText(text); int charIndex = JavaScriptHelper.findIndexOfFirstOpeningBracket(parseText); env.setRecoverFromErrors(true); Parser parser = new Parser(env); StringReader r = new StringReader(parseText); AstRoot root = parser.parse(r, null, 0); CompilerNodeVisitor visitor = new CompilerNodeVisitor(charIndex == 0); root.visitAll(visitor); return lastJavaScriptType; }
/** * Resolve node type to TypeDeclaration. Called instead of #compileText(String text) when document is already parsed * @param node AstNode to resolve * @return TypeDeclaration for node or null if not found. */ @Override public TypeDeclaration resolveParamNode(String text) throws IOException { if(text != null) { CompilerEnvirons env = JavaScriptParser.createCompilerEnvironment(new JavaScriptParser.JSErrorReporter(), provider.getLanguageSupport()); int charIndex = JavaScriptHelper.findIndexOfFirstOpeningBracket(text); env.setRecoverFromErrors(true); Parser parser = new Parser(env); StringReader r = new StringReader(text); AstRoot root = parser.parse(r, null, 0); CompilerNodeVisitor visitor = new CompilerNodeVisitor(charIndex == 0); root.visitAll(visitor); } return lastJavaScriptType != null ? lastJavaScriptType.getType() : provider.getTypesFactory().getDefaultTypeDeclaration(); }
private AstRoot parse(CharSequence cs) { CompilerEnvirons compilerEnv = new CompilerEnvirons(); compilerEnv.initFromContext(cx); ErrorReporter compilationErrorReporter = compilerEnv.getErrorReporter(); Parser p = new Parser(compilerEnv, compilationErrorReporter); return p.parse(cs.toString(), "<eval>", 1); }
/** * Asserts that the value returned by {@link AstRoot#toSource()} after * the given input source was parsed equals the specified expected output source. * * @param source the JavaScript source to be parsed * @param expectedOutput the JavaScript source that is expected to be * returned by {@link AstRoot#toSource()} */ private void assertSource(String source, String expectedOutput) { CompilerEnvirons env = new CompilerEnvirons(); env.setLanguageVersion(Context.VERSION_1_7); Parser parser = new Parser(env); AstRoot root = parser.parse(source, null, 0); Assert.assertEquals(expectedOutput, root.toSource()); }
private void assertSource(String source, String expectedOutput) { CompilerEnvirons env = new CompilerEnvirons(); env.setLanguageVersion(Context.VERSION_ES6); Parser parser = new Parser(env); AstRoot root = parser.parse(source, null, 0); Assert.assertEquals(expectedOutput, root.toSource()); }
private AstRoot parse( String string, final String [] errors, final String [] warnings, boolean jsdoc) { TestErrorReporter testErrorReporter = new TestErrorReporter(errors, warnings) { @Override public EvaluatorException runtimeError( String message, String sourceName, int line, String lineSource, int lineOffset) { if (errors == null) { throw new UnsupportedOperationException(); } return new EvaluatorException( message, sourceName, line, lineSource, lineOffset); } }; environment.setErrorReporter(testErrorReporter); environment.setRecordingComments(true); environment.setRecordingLocalJsDocComments(jsdoc); Parser p = new Parser(environment, testErrorReporter); AstRoot script = null; try { script = p.parse(string, null, 0); } catch (EvaluatorException e) { if (errors == null) { // EvaluationExceptions should not occur when we aren't expecting // errors. throw e; } } assertTrue(testErrorReporter.hasEncounteredAllErrors()); assertTrue(testErrorReporter.hasEncounteredAllWarnings()); return script; }
private AstRoot parseAsReader(String string) throws IOException { TestErrorReporter testErrorReporter = new TestErrorReporter(null, null); environment.setErrorReporter(testErrorReporter); environment.setRecordingComments(true); environment.setRecordingLocalJsDocComments(true); Parser p = new Parser(environment, testErrorReporter); AstRoot script = p.parse(new StringReader(string), null, 0); assertTrue(testErrorReporter.hasEncounteredAllErrors()); assertTrue(testErrorReporter.hasEncounteredAllWarnings()); return script; }
/** * generate constraints from JavaScript code * @param code the AST to generate constraints for */ public void generateConstraints(String code) { Parser p = new Parser(); astRoot = p.parse(code, "", 1); generateConstraints(astRoot); }
public List<AstRoot> getAsts() throws IOException { List<AstRoot> asts = new LinkedList<AstRoot>(); for (Map.Entry<String, Reader> file : files.entrySet()) { Parser parser = new Parser(); asts.add(parser.parse(file.getValue(), file.getKey(), 1)); } return asts; }
public void testParseComplexStuff() throws Exception { Reader source = new InputStreamReader( this.getClass().getResourceAsStream("browser_debug.js")); Parser parser = new Parser(); AstRoot ast = parser.parse(source, "browser_debug.js", 1); String debugString = ast.debugPrint(); assertTrue(debugString.contains("getRequiresAndProvides")); assertTrue(debugString.contains("ARRAYLIT")); }
