Java Flags.AUTOMATIC_MODULE屬性代碼示例

private void completeAutomaticModule(ModuleSymbol msym) throws CompletionFailure {
    ListBuffer<Directive> directives = new ListBuffer<>();

    directives.addAll(msym.directives);

    ListBuffer<RequiresDirective> requires = new ListBuffer<>();

    for (ModuleSymbol ms : allModules()) {
        if (ms == syms.unnamedModule || ms == msym)
            continue;
        Set<RequiresFlag> flags = (ms.flags_field & Flags.AUTOMATIC_MODULE) != 0 ?
                EnumSet.of(RequiresFlag.TRANSITIVE) : EnumSet.noneOf(RequiresFlag.class);
        RequiresDirective d = new RequiresDirective(ms, flags);
        directives.add(d);
        requires.add(d);
    }

    RequiresDirective requiresUnnamed = new RequiresDirective(syms.unnamedModule);
    directives.add(requiresUnnamed);
    requires.add(requiresUnnamed);

    msym.requires = requires.toList();
    msym.directives = directives.toList();
}
 

@Override
public void complete(Symbol sym) throws CompletionFailure {
    ModuleSymbol msym = moduleFinder.findModule((ModuleSymbol) sym);

    if (msym.kind == ERR) {
        //make sure the module is initialized:
        msym.directives = List.nil();
        msym.exports = List.nil();
        msym.provides = List.nil();
        msym.requires = List.nil();
        msym.uses = List.nil();
    } else if ((msym.flags_field & Flags.AUTOMATIC_MODULE) != 0) {
        setupAutomaticModule(msym);
    } else {
        msym.module_info.complete();
    }

    // If module-info comes from a .java file, the underlying
    // call of classFinder.fillIn will have called through the
    // source completer, to Enter, and then to Modules.enter,
    // which will call completeModule.
    // But, if module-info comes from a .class file, the underlying
    // call of classFinder.fillIn will just call ClassReader to read
    // the .class file, and so we call completeModule here.
    if (msym.module_info.classfile == null || msym.module_info.classfile.getKind() == Kind.CLASS) {
        completeModule(msym);
    }
}
 

private Set<ModuleSymbol> computeTransitiveClosure(Set<? extends ModuleSymbol> base,
                                                   Set<? extends ModuleSymbol> rootModules,
                                                   Set<ModuleSymbol> observable) {
    List<ModuleSymbol> primaryTodo = List.nil();
    List<ModuleSymbol> secondaryTodo = List.nil();

    for (ModuleSymbol ms : base) {
        if (rootModules.contains(ms)) {
            primaryTodo = primaryTodo.prepend(ms);
        } else {
            secondaryTodo = secondaryTodo.prepend(ms);
        }
    }

    Set<ModuleSymbol> result = new LinkedHashSet<>();
    result.add(syms.java_base);

    while (primaryTodo.nonEmpty() || secondaryTodo.nonEmpty()) {
        try {
            ModuleSymbol current;
            boolean isPrimaryTodo;
            if (primaryTodo.nonEmpty()) {
                current = primaryTodo.head;
                primaryTodo = primaryTodo.tail;
                isPrimaryTodo = true;
            } else {
                current = secondaryTodo.head;
                secondaryTodo = secondaryTodo.tail;
                isPrimaryTodo = false;
            }
            if (observable != null && !observable.contains(current))
                continue;
            if (!result.add(current) || current == syms.unnamedModule || ((current.flags_field & Flags.AUTOMATIC_MODULE) != 0))
                continue;
            current.complete();
            if (current.kind == ERR && (isPrimaryTodo || base.contains(current)) && warnedMissing.add(current)) {
                log.error(Errors.ModuleNotFound(current));
            }
            for (RequiresDirective rd : current.requires) {
                if (rd.module == syms.java_base) continue;
                if ((rd.isTransitive() && isPrimaryTodo) || rootModules.contains(current)) {
                    primaryTodo = primaryTodo.prepend(rd.module);
                } else {
                    secondaryTodo = secondaryTodo.prepend(rd.module);
                }
            }
        } catch (CompletionFailure ex) {
            chk.completionError(null, ex);
        }
    }

    return result;
}