Home /Modules/impl/java_handler.cpp

java_handler.cpp

impl/frontend/java/java_handler.cpp · 165 line(s) · c

// ===========================================================================
// java_handler.cpp -- the Java language handler module for the SLeeLa compiler.
// ===========================================================================
// Everything the compiler does specially for Java-authored or Java-referencing
// documents lives in this directory and is reached only through the neutral
// LanguageHandler interface (frontend/language_handler.h):
//
//   * the `spark` Preonem document marker (SLEELA.syntax section 43)
//   * resolving a package-qualified reference (java.lang.Throwable) to the
//     simple-named /lib class that stands for it
//   * erasing Java signature types (type variables, java.util.List<E>) to the
//     VM types SLeeLa supports
//   * naming the Java String method library and the VM-fault exception library
//     and deciding when the driver must seed them
//   * validating Java compatibility metadata (java_compat.h)
//
// The module registers itself with a static Registrar. Removing this file from
// FE_SRC in impl/Makefile removes Java support; the compiler, the VM and the
// runtime are untouched. Source semantics only: no JVM is involved here (the
// optional JVM host launch is a separate concern, see COMPILER-JAVA-REVIEW.md).
// Specification: Java Specific Section, lib/java/JAVA.SPEC.md.
// ===========================================================================
#include "java_handler.h"
#include "java_compat.h"
#include <algorithm>
#include <regex>
namespace sleela {
namespace javahandler {
std::string simpleName(const std::string& q){
    const std::size_t dot=q.rfind('.');
    return dot==std::string::npos?q:q.substr(dot+1);
}
bool isQualified(const std::string& n){ return n.find('.')!=std::string::npos; }

class JavaHandler : public LanguageHandler {
public:
    const char* name() const override { return "java"; }

    std::vector<DocumentMarker> documentMarkers() const override {
        // Spark marker (syntax 3.0, SLEELA.syntax section 43): a Preonem
        // indicating Java-style declarative source. Declarative only.
        return { DocumentMarker{"spark",SyntaxVersion{3,0}} };
    }

    // A qualified name falls back to its simple name only when that class came
    // from /lib (fromLibrary), so a local class named Object cannot impersonate
    // java.lang.Object.
    std::string resolveReference(const ClassIndexMap& byName,const std::string& declared) const override {
        if(isQualified(declared)){
            auto it=byName.find(simpleName(declared));
            if(it!=byName.end() && it->second && it->second->fromLibrary) return it->first;
        }
        return "";
    }

    // A declared type variable (E, T, K ...) and any package-qualified
    // reference type (java.util.List<E>) erase to Any, java.lang.String to
    // String. Array suffixes are preserved; the source keeps the Java spelling.
    std::string eraseSignatureType(const std::string& source,const std::vector<std::vector<std::string>>& typeVars) const override {
        std::string base=source; std::string dims;
        while(base.size()>=2 && base.compare(base.size()-2,2,"[]")==0){ dims+="[]"; base.resize(base.size()-2); }
        std::string raw=base.substr(0,base.find('<'));
        for(auto it=typeVars.rbegin(); it!=typeVars.rend(); ++it)
            for(const auto& v:*it) if(v==raw) return "Any"+dims;
        if(raw.find('.')!=std::string::npos && !raw.empty() && raw[0]>='a' && raw[0]<='z'){
            if(raw=="java.lang.String") return "String"+dims;
            return "Any"+dims;
        }
        return "";
    }

    std::string stringMethodLibrary() const override { return "JavaStringMethods"; }
    std::string faultFunction() const override { return "SLJavaFaults::make"; }

    // SLEELA.syntax 37.5: a Java-style document (spark marker or an
    // `import java...`) that uses try gets the VM-fault exception library, so a
    // division by zero inside the try throws ArithmeticException.
    std::vector<std::string> libraryNeeds(const Program& program,const std::string& source) const override {
        for(const auto& cls:program.classes) if(cls.name=="SLJavaFaults") return {};
        bool javaStyle=program.markers.count("spark")>0;
        for(const auto& im:program.imports) if(im.rfind("java",0)==0) javaStyle=true;
        static const std::regex tryWord("\\btry\\b");
        if(javaStyle && std::regex_search(source,tryWord)) return {"SLJavaFaults"};
        return {};
    }


    // Java tier selection among library units that share a simple name.
    // Generated JDK API documentation (docs/api envelopes) duplicates real
    // class names; java/jdk-28/<module>/... holds one reference file per JDK 28
    // type. Rules (SLEELA.syntax 43; lib/java/jdk-28/README.md "Name clashes"):
    //   * a real source unit beats docs/api and jdk-28 reference files;
    //   * with only reference files, java/jdk-28 beats docs/api;
    //   * `import java.jdk-28;` selects the JDK 28 tier outright;
    //   * several JDK 28 clashes (java.util.List vs java.awt.List, ...) resolve
    //     by rank: longest matching import root, module (java.base, other java.*,
    //     jdk.*), package (java.lang, java.util, java.io, java.nio, java.net,
    //     java.time, java.math, java.text, rest), fewer segments, byte order.
    std::vector<std::string> filterLibraryCandidates(const std::string&,const std::vector<std::string>& paths,const std::vector<std::string>& roots) const override {
        static const std::string kJdk28="java/jdk-28/";
        auto isJdk28=[&](const std::string& p){ return p.rfind(kJdk28,0)==0; };
        auto isReference=[&](const std::string& p){ return p.find("/docs/api/")!=std::string::npos || isJdk28(p); };
        bool hasNonDoc=false, hasJdk28=false;
        for(const auto& p:paths){ if(!isReference(p)) hasNonDoc=true; if(isJdk28(p)) hasJdk28=true; }
        const bool selected=std::find(roots.begin(),roots.end(),std::string("java/jdk-28"))!=roots.end();
        const bool onlyJdk28=selected&&hasJdk28;
        if(onlyJdk28) hasNonDoc=false;
        std::vector<std::string> kept, jdk;
        for(const auto& p:paths){
            if(onlyJdk28 && !isJdk28(p)) continue;
            if(hasNonDoc && isReference(p)) continue;
            if(!hasNonDoc && hasJdk28 && !isJdk28(p)) continue;
            kept.push_back(p);
            if(isJdk28(p)) jdk.push_back(p);
        }
        if(jdk.size()<=1) return kept;
        auto rootLen=[&](const std::string& p){
            size_t best=0;
            for(const auto& r:roots) if(p.rfind(r+"/",0)==0) best=std::max(best,r.size());
            return best;
        };
        auto moduleTier=[&](const std::string& p){
            const std::string rest=p.substr(kJdk28.size());
            if(rest.rfind("java.base/",0)==0) return 0;
            if(rest.rfind("java.",0)==0) return 1;
            return 2;
        };
        auto packageRank=[&](const std::string& p){
            static const char* order[]={"/java/lang/","/java/util/","/java/io/","/java/nio/","/java/net/","/java/time/","/java/math/","/java/text/"};
            const std::string rest=p.substr(kJdk28.size());
            const size_t slash=rest.find('/');
            const std::string pkg=slash==std::string::npos?rest:rest.substr(slash);
            for(int i=0;i<8;++i){
                const std::string o=order[i];
                if(pkg.rfind(o,0)==0 && pkg.find('/',o.size())==std::string::npos) return i;
            }
            return 8;
        };
        auto depth=[](const std::string& p){ return (int)std::count(p.begin(),p.end(),'/'); };
        auto better=[&](const std::string& a,const std::string& b){
            const size_t ra=rootLen(a), rb=rootLen(b);
            if(ra!=rb) return ra>rb;
            const int ma=moduleTier(a), mb=moduleTier(b);
            if(ma!=mb) return ma<mb;
            const int pa=packageRank(a), pb=packageRank(b);
            if(pa!=pb) return pa<pb;
            const int da=depth(a), db=depth(b);
            if(da!=db) return da<db;
            return a<b;
        };
        std::string choice=jdk[0];
        for(const auto& c:jdk) if(better(c,choice)) choice=c;
        std::vector<std::string> out;
        for(const auto& p:kept) if(!isJdk28(p) || p==choice) out.push_back(p);
        return out;
    }

    void validateProgram(const Program& p) const override { validateJavaCompatibilityMetadata(p); }
};

static JavaHandler g_handler;
static lang::Registrar g_registrar(&g_handler);
}
}