Method type

chapter23/src/main/java/com/seaofnodes/simple/Parser.java:898–958

()

    // t = int|i8|i16|i32|i64|u8|u16|u32|u64|byte|bool | flt|f32|f64 | val | var | struct[?]
    private Type type() {
        int old1 = pos();
        // Only type with a leading `{` is a function pointer...
        if( peek('{') ) return typeFunPtr();

        // Otherwise you get a type name
        String tname = _lexer.matchId();
        if( tname==null ) return null;

        // Convert the type name to a type.
        Type t0 = TYPES.get(tname);
        // No new types as keywords
        if( t0 == null && KEYWORDS.contains(tname) )
            return posT(old1);
        if( t0 == Type.BOTTOM || t0 == Type.TOP ) return t0; // var/val type inference

        // Check for subtype.
        while( true ) {
            int old2 = pos();
            if( !match(".") )  break;
            String sname = _lexer.matchId();
            if( sname==null ) { pos(old2); break; }
            String tsname = tname+"."+sname;
            t0 = TYPES.get(tsname);
            if( t0==null ) { pos(old2); t0 = TYPES.get(tname); break; }
            tname = tsname;
        }

        // Still no type found?  Assume forward reference
        Type t1 = t0 == null ? TypeMemPtr.make(TypeStruct.open(tname)) :t0; // Null: assume a forward ref type
        // Nest arrays and '?' as needed
        Type t2 = t1;
        while( true ) {
            if( match("?") ) {
                if( !(t2 instanceof TypeMemPtr tmp) )
                    throw error("Type "+t0+" cannot be null");
                if( tmp.nullable() ) throw error("Type "+t2+" already allows null");
                t2 = tmp.makeNullable();
            } else if( match("[~]") ) {
                t2 = typeAry(t2,true);
            } else if( match("[]") ) {
                t2 = typeAry(t2,false);
            } else
                break;
        }

        // Check no forward ref
        if( t0 != null ) return t2;
        // Check valid forward ref, after parsing all the type extra bits.
        // Cannot check earlier, because cannot find required 'id' until after "[]?" syntax
        int old2 = pos();
        match("!");
        String id = _lexer.matchId();
        if( !(peek(',') || peek(';') || match("->")) || id==null )
            return posT(old1);  // Reset lexer to reparse
        pos(old2);              // Reset lexer to reparse
        // Yes a forward ref, so declare it
        TYPES.put(tname,t1);