Versionamento dell'@import del file style.css del tema genitore

Non devi usare @import. In effetti, è meglio evitarlo. Utilizzare un approccio con enqueue è probabilmente la scelta migliore in ogni caso.

Ecco la parte rilevante del codice di twentythirteen:

function twentythirteen_scripts_styles() {
...
    // Carica il foglio di stile principale
    wp_enqueue_style( 'twentythirteen-style', get_stylesheet_uri(), array(), '2013-07-18' );
...
}
add_action( 'wp_enqueue_scripts', 'twentythirteen_scripts_styles' );

Ecco cosa dovresti fare nel tuo codice:

function child_scripts_styles() {
    wp_enqueue_style( 'child-style', get_stylesheet_directory_uri().'/css/main.css', array('twentythirteen-style'), 'LA_TUA_VERSIONE_TEMA' );
}
add_action( 'wp_enqueue_scripts', 'child_scripts_styles' );

Se il tuo main.css deve essere caricato dopo lo style.css del tema genitore, basta renderlo dipendente da quest'ultimo.

Ora, se hai anche un file B.css nel child theme, imposti le dipendenze di conseguenza:

function child_scripts_styles() {
    wp_enqueue_style( 'child-B-style', get_stylesheet_directory_uri().'/B.css', array('twentythirteen-style'), 'LA_TUA_VERSIONE_TEMA' );
    wp_enqueue_style( 'child-style', get_stylesheet_directory_uri().'/css/main.css', array('child-B-style'), 'LA_TUA_VERSIONE_TEMA' );
}
add_action( 'wp_enqueue_scripts', 'child_scripts_styles' );

Assicurati che le dipendenze che definisci per ogni elemento riflettano effettivamente le dipendenze reali. Se main.css deve essere caricato dopo B.css, allora dipende da esso. Se B.css deve essere caricato dopo lo style.css del tema genitore, allora B dipende da quello. Il sistema di enqueue risolverà l'ordinamento per te.

E se in realtà non stai utilizzando lo style.css del child theme per nulla, non sei obbligato a caricarlo. Può essere semplicemente un segnaposto per le informazioni dell'header del tuo tema. Non lo usi? Non caricarlo.

Inoltre, cosa stai facendo che è così dipendente dall'ordine di caricamento qui? Nella maggior parte dei casi, al CSS non interessa l'ordine di caricamento. Il CSS dipende maggiormente dalla specificità dei selettori. Se vuoi sovrascrivere qualcosa, rendi il tuo selettore più specifico. Può essere il primo, l'ultimo o qualsiasi posizione intermedia, il selettore più specifico vince sempre.

Modifica

Leggendo i tuoi commenti e osservando più da vicino il codice, vedo dove sta l'errore. Il codice di twenty-thirteen sta caricando "get_stylesheet_uri()", che nel caso di un child theme sarebbe il file style.css del child theme, non quello del genitore. Ecco perché l'@import funziona e mantiene lo stesso ordine (che, ripeto, non è così importante come pensi).

In tal caso, se non vuoi usare l'import, ti consiglio di caricare direttamente lo style.css del tema genitore. In questo modo:

function child_scripts_styles() {
    wp_enqueue_style( 'parent-style', get_template_directory_uri().'/style.css', array() );
}
add_action( 'wp_enqueue_scripts', 'child_scripts_styles' );

Il codice nel functions.php del child theme viene eseguito per primo, quindi il tuo wp_enqueue_scripts verrà eseguito per primo e caricherà lo style.css del tema genitore, cosa che il tema genitore non fa da solo (perché in realtà sta caricando lo style.css del tuo child theme). Non rendendolo dipendente da nulla, come nel caso del tema genitore, verrà semplicemente inserito nell'output correttamente. Nota che l'ordine di questo file e di genericons.css non ha importanza, perché l'originale "twentythirteen-style" non ha genericons.css come dipendenza elencata.

Il tuo style.css del child theme verrà caricato e, onestamente, è qui che dovresti inserire le modifiche per il child theme, non in un main.css separato. Non c'è nulla che ti impedisca di inserire le tue modifiche lì, ma non c'è una vera ragione per avere un file CSS aggiuntivo.

avviso

Questa soluzione non rispetta le dipendenze del tema genitore! Cambiando il nome dell'handle del tema genitore si influisce sulla catena delle dipendenze impostata nel tema genitore. Vedi la mia soluzione molto più semplice nella mia altra risposta.

risposta originale

Sebbene la risposta di Otto sia abbastanza buona, alla fine ho implementato questo nel functions.php del mio tema child

function my_theme_styles() {
    global $wp_styles;
    $parentOriginalHandle = 'twentythirteen-style';
    $parentNewHandle = 'parent-style';

    // Deregistra il nostro style.css che era stato accodato dal tema genitore; vogliamo
    // controllare noi stessi la versione.
    $parentStyleVersion = $wp_styles->registered[$parentOriginalHandle]->ver;
    $parentDeps = $wp_styles->registered[$parentOriginalHandle]->deps;
    wp_deregister_style($parentOriginalHandle);

    // Accoda lo style.css del tema genitore con la versione originale invece
    // di importarlo via @import nello style.css del tema child
    wp_register_style($parentNewHandle, get_template_directory_uri() . '/style.css',
        $parentDeps, $parentStyleVersion);

    // Accoda il nostro style.css con la nostra versione
    $themeVersion = wp_get_theme()->get('Version');
    wp_enqueue_style($parentOriginalHandle, get_stylesheet_directory_uri() . '/style.css',
        [$parentNewHandle], $themeVersion);
}

// Esegui questa azione dopo che il tema genitore ha accodato i suoi stili.
add_action('wp_enqueue_scripts', 'my_theme_styles', 20);

Mantiene l'ordinamento e i numeri di versione dello style.css del tema genitore mentre controlla la versione dello style.css del tema child.