com/sun/tools/javac/tree/TreeCopier.java - 349 | List defs = copy(t.defs, p); - 350 | return M.at(t.pos).TopLevel(defs); 351 | } 352 | 353 | public JCTree visitPackage(PackageTree node, P p) { - 354 | JCPackageDecl t = (JCPackageDecl) node; - 355 | List annotations = copy(t.annotations, p); - 357 | return M.at(t.pos).PackageDecl(annotations, pid); com/sun/tools/javac/tree/TreeInfo.java 409 | case PACKAGEDEF: { + 410 | JCPackageDecl pd = (JCPackageDecl)tree; + 411 | return pd.annotations.isEmpty() ? pd.pos : + 412 | pd.annotations.head.pos; 413 | } 796 | case PACKAGEDEF: + 797 | return ((JCPackageDecl) node).packge; 830 | case PACKAGEDEF: com/sun/tools/doclint/DocLint.java 45 |import com.sun.source.tree.PackageTree; 350 | public Void visitPackage(PackageTree tree, Void ignore) { 351 | visitDecl(tree, null); 352 | return super.visitPackage(tree, ignore); com/sun/tools/javac/tree/TreeTranslator.java - 119 | tree.defs = translate(tree.defs); - 120 | result = tree; - 121 | } 122 | 123 | public void visitPackageDef(JCPackageDecl tree) { - 124 | tree.annotations = translate(tree.annotations); com/sun/tools/doclint/Checker.java 78 |import com.sun.source.tree.Tree; + 149 | if (p.getLeaf().getKind() == Tree.Kind.PACKAGE) { 150 | // If p points to a package, the implied declaration is the com/sun/source/util/SimpleTreeVisitor.java 68 | public R visitPackage(PackageTree node, P p) { - 69 | return defaultAction(node, p); 70 | } 71 | com/sun/tools/javac/comp/Enter.java + 291 | JCPackageDecl pd = tree.getPackage(); + 292 | if (pd != null) { + 293 | tree.packge = pd.packge = syms.enterPackage(TreeInfo.fullName(pd.pid)); + 294 | if ( pd.annotations.nonEmpty() 295 | || pkginfoOpt == PkgInfo.ALWAYS 296 | || tree.docComments != null) { + 299 | } else if (pd.annotations.nonEmpty()) { + 300 | log.error(pd.annotations.head.pos(), + 309 | Env packageEnv = isPkgInfo ? topEnv.dup(pd) : null; + 314 | if (env0 != null) { - 317 | log.warning(pd != null ? pd.pid.pos() : null, + 322 | typeEnvs.put(tree.packge, packageEnv); + 337 | todo.append(packageEnv); com/sun/tools/javac/comp/Lower.java 2411 | public void visitPackageDef(JCPackageDecl tree) { + 2412 | if (!needPackageInfoClass(tree)) + 2413 | return; 2414 | + 2415 | Name name = names.package_info; + 2416 | long flags = Flags.ABSTRACT | Flags.INTERFACE; + 2417 | if (target.isPackageInfoSynthetic()) 2418 | // package-info is marked SYNTHETIC in JDK 1.6 and later releases + 2419 | flags = flags | Flags.SYNTHETIC; + 2420 | JCClassDecl packageAnnotationsClass + 2421 | = make.ClassDef(make.Modifiers(flags, tree.getAnnotations()), + 2422 | name, List.nil(), + 2423 | null, List.nil(), List.nil()); + 2424 | ClassSymbol c = tree.packge.package_info; + 2425 | c.flags_field |= flags; + 2426 | c.setAttributes(tree.packge); + 2427 | ClassType ctype = (ClassType) c.type; + 2428 | ctype.supertype_field = syms.objectType; + 2429 | ctype.interfaces_field = List.nil(); + 2430 | packageAnnotationsClass.sym = c; 2431 | + 2432 | translated.append(packageAnnotationsClass); 2435 | private boolean needPackageInfoClass(JCPackageDecl pd) { + 2440 | return pd.getAnnotations().nonEmpty(); - 2443 | pd.packge.getDeclarationAttributes()) { com/sun/tools/javac/model/JavacElements.java 173 | public void visitPackageDef(JCPackageDecl tree) { 174 | result = tree.annotations; com/sun/source/util/TreeScanner.java + 117 | R r = scan(node.getPackage(), p); 123 | public R visitPackage(PackageTree node, P p) { + 124 | R r = scan(node.getAnnotations(), p); + 125 | r = scanAndReduce(node.getPackageName(), p, r); + 126 | return r; 127 | } 128 | com/sun/tools/javac/tree/Pretty.java 370 | + 373 | l.nonEmpty() && 374 | (cdef == null || + 375 | l.head.hasTag(IMPORT) || l.head.hasTag(PACKAGEDEF)); + 376 | l = l.tail) { 426 | public void visitPackageDef(JCPackageDecl tree) { 427 | try { + 428 | printDocComment(tree); + 429 | printAnnotations(tree.annotations); + 430 | if (tree.pid != null) { + 431 | print("package "); + 432 | printExpr(tree.pid); + 433 | print(";"); + 434 | println(); 435 | } - 436 | } catch (IOException e) { - 437 | throw new UncheckedIOException(e); + 438 | } + 439 | } 440 | com/sun/tools/javac/tree/JCTree.java 92 | /** Package level definitions. 93 | */ 94 | PACKAGEDEF, 95 | 503 | protected JCCompilationUnit(List defs) { 510 | 511 | public JCPackageDecl getPackage() { 512 | // PackageDecl must be the first entry if it exists 513 | if (!defs.isEmpty() && defs.head.hasTag(PACKAGEDEF)) 514 | return (JCPackageDecl)defs.head; 515 | return null; 516 | } 518 | JCPackageDecl pd = getPackage(); 519 | return pd != null ? pd.getAnnotations() : List.nil(); 521 | public ExpressionTree getPackageName() { 522 | JCPackageDecl pd = getPackage(); 523 | return pd != null ? pd.getPackageName() : null; 524 | } 525 | 531 | else if (!tree.hasTag(PACKAGEDEF) && !tree.hasTag(SKIP)) 545 | if (!typeDefs.head.hasTag(PACKAGEDEF) && !typeDefs.head.hasTag(IMPORT)) 561 | * Package definition. 562 | */ 563 | public static class JCPackageDecl extends JCTree implements PackageTree { 564 | public List annotations; 565 | /** The tree representing the package clause. */ 566 | public JCExpression pid; 567 | public PackageSymbol packge; 568 | public JCPackageDecl(List annotations, JCExpression pid) { 569 | this.annotations = annotations; 570 | this.pid = pid; 571 | } 572 | @Override 573 | public void accept(Visitor v) { v.visitPackageDef(this); } 574 | public Kind getKind() { 575 | return Kind.PACKAGE; 576 | } 577 | public List getAnnotations() { 578 | return annotations; 579 | } 580 | public JCExpression getPackageName() { 581 | return pid; 582 | } 583 | @Override 584 | public R accept(TreeVisitor v, D d) { 585 | return v.visitPackage(this, d); 586 | } 587 | @Override 588 | public Tag getTag() { 589 | return PACKAGEDEF; 590 | } 591 | } 592 | 593 | /** 2475 | JCCompilationUnit TopLevel(List defs); 2476 | JCPackageDecl PackageDecl(List annotations, 2477 | JCExpression pid); 2565 | public void visitPackageDef(JCPackageDecl that) { visitTree(that); } com/sun/tools/javac/tree/TreeMaker.java 119 | * @param defs a list of PackageDef, ClassDef, Import, and Skip 121 | public JCCompilationUnit TopLevel(List defs) { 124 | || node instanceof JCPackageDecl + 131 | JCCompilationUnit tree = new JCCompilationUnit(defs); + 132 | tree.pos = pos; + 133 | return tree; 134 | } 135 | 136 | public JCPackageDecl PackageDecl(List annotations, 137 | JCExpression pid) { + 138 | Assert.checkNonNull(annotations); + 139 | Assert.checkNonNull(pid); + 140 | JCPackageDecl tree = new JCPackageDecl(annotations, pid); com/sun/source/tree/TreeVisitor.java - 91 | R visitPackage(PackageTree node, P p); com/sun/tools/javac/comp/Flow.java 391 | 392 | public void visitPackageDef(JCPackageDecl tree) { 393 | // Do nothing for PackageDecl 394 | } com/sun/tools/javac/parser/JavacParser.java + 3088 | ListBuffer defs = new ListBuffer<>(); + 3093 | int packagePos = token.pos; + 3094 | List annotations = List.nil(); + 3098 | annotations = mods.annotations; + 3102 | JCExpression pid = qualident(false); + 3104 | JCPackageDecl pd = F.at(packagePos).PackageDecl(annotations, pid); + 3105 | attach(pd, firstToken.comment(CommentStyle.JAVADOC)); + 3106 | consumedToplevelDoc = true; + 3107 | storeEnd(pd, token.pos); + 3108 | defs.append(pd); 3110 | + 3139 | JCTree.JCCompilationUnit toplevel = F.at(firstToken.pos).TopLevel(defs.toList()); com/sun/tools/javadoc/DocEnv.java 746 | TreePath getTreePath(JCCompilationUnit toplevel, JCPackageDecl tree) { + 747 | TreePath p = treePaths.get(tree); + 748 | if (p == null) + 749 | treePaths.put(tree, p = new TreePath(getTreePath(toplevel), tree)); + 750 | return p; 751 | } 752 | com/sun/source/tree/Tree.java 211 | * Used for instances of {@link PackageTree}. 212 | * @since 1.9 213 | */ + 214 | PACKAGE(PackageTree.class), 215 | 216 | /** com/sun/source/tree/PackageTree.java - 1 |/* - 2 | * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - 4 | * - 5 | * This code is free software; you can redistribute it and/or modify it - 6 | * under the terms of the GNU General Public License version 2 only, as - 7 | * published by the Free Software Foundation. Oracle designates this - 8 | * particular file as subject to the "Classpath" exception as provided - 9 | * by Oracle in the LICENSE file that accompanied this code. - 10 | * - 11 | * This code is distributed in the hope that it will be useful, but WITHOUT - 12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - 13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - 14 | * version 2 for more details (a copy is included in the LICENSE file that - 15 | * accompanied this code). - 16 | * - 17 | * You should have received a copy of the GNU General Public License version - 18 | * 2 along with this work; if not, write to the Free Software Foundation, - 19 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - 20 | * - 21 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - 22 | * or visit www.oracle.com if you need additional information or have any - 23 | * questions. - 24 | */ - 25 | - 26 |package com.sun.source.tree; - 27 | - 28 |import java.util.List; - 29 | - 30 |/** - 31 | * Represents the package declaration. - 32 | * - 33 | * @jls sections 7.3, and 7.4 - 34 | * - 35 | * @author Paul Govereau - 36 | * @since 1.9 - 37 | */ - 38 |@jdk.Exported - 39 |public interface PackageTree extends Tree { - 40 | List getAnnotations(); - 41 | ExpressionTree getPackageName(); - 42 |} com/sun/source/tree/CompilationUnitTree.java - 44 | - 45 | /** - 46 | * Return the PackageTree associated with this compilation unit. - 47 | * @since 1.9 - 48 | */ - 49 | PackageTree getPackage(); com/sun/tools/javac/comp/MemberEnter.java + 496 | DiagnosticPosition prevLintPos = deferredLintHandler.immediate(); + 497 | Lint prevLint = chk.setLint(lint); 498 | 499 | try { 500 | // Import-on-demand java.lang. + 501 | importAll(tree.pos, syms.enterPackage(names.java_lang), env); 502 | 503 | // Process the package def and all import clauses. + 504 | memberEnter(tree.defs, env); 505 | } finally { + 506 | chk.setLint(prevLint); + 507 | deferredLintHandler.setPos(prevLintPos); + 508 | } + 509 | } 510 | 511 | public void visitPackageDef(JCPackageDecl tree) { + 515 | Symbol p = env.toplevel.packge; + 527 | annotate.annotateLater(tree.annotations, env, env.toplevel.packge, null); com/sun/tools/javadoc/JavadocEnter.java 30 |import com.sun.source.util.TreePath; + 88 | JCPackageDecl pd = tree.getPackage(); + 89 | TreePath tp = pd == null ? docenv.getTreePath(tree) : docenv.getTreePath(tree, pd); + 90 | docenv.makePackageDoc(tree.packge, tp); com/sun/tools/javac/main/JavaCompiler.java + 604 | JCCompilationUnit tree = make.TopLevel(List.nil()); + 691 | make.TopLevel(List.nil()); - 770 | tree = make.TopLevel(List.nil()); + 1442 | if (env.tree.hasTag(JCTree.Tag.PACKAGEDEF)) { com/sun/tools/javac/tree/TreeScanner.java + 66 | scan(tree.defs); + 67 | } 68 | 69 | public void visitPackageDef(JCPackageDecl tree) { + 70 | scan(tree.annotations);