about summary refs log tree commit diff
path: root/tests/ui/stability-attribute/stability-privacy-interaction.rs
blob: e02816ae1e739f0750a6a0c45ed488255ec39038 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
//! Regression test for issue #38412: interaction between stability attributes and privacy
//!
//! Tests that the compiler correctly handles the interaction between feature gates
//! and privacy/visibility rules. Specifically verifies that enabled unstable features
//! are accessible while disabled ones are properly rejected.

//@ aux-build:pub-and-stability.rs

// Enable `unstable_declared` but not `unstable_undeclared` to test
// that the compiler allows enabled features but rejects disabled ones
#![feature(unstable_declared)]

extern crate pub_and_stability;
use pub_and_stability::{Record, Trait, Tuple};

fn main() {
    // Test struct field access patterns
    let Record { .. } = Record::new();

    let Record {
        a_stable_pub: _,
        a_unstable_declared_pub: _,
        ..
    } = Record::new();

    let Record {
        a_stable_pub: _,
        a_unstable_declared_pub: _,
        a_unstable_undeclared_pub: _,  //~ ERROR use of unstable library feature `unstable_undeclared`
        ..
    } = Record::new();

    let r = Record::new();
    let t = Tuple::new();

    // Test field access with different stability/privacy combinations
    r.a_stable_pub;
    r.a_unstable_declared_pub;
    r.a_unstable_undeclared_pub; //~ ERROR use of unstable library feature
    r.b_crate;                   //~ ERROR is private
    r.c_mod;                     //~ ERROR is private
    r.d_priv;                    //~ ERROR is private

    t.0;
    t.1;
    t.2;                         //~ ERROR use of unstable library feature
    t.3;                         //~ ERROR is private
    t.4;                         //~ ERROR is private
    t.5;                         //~ ERROR is private

    // Test trait method access
    r.stable_trait_method();
    r.unstable_declared_trait_method();
    r.unstable_undeclared_trait_method(); //~ ERROR use of unstable library feature

    // Test inherent method access
    r.stable();
    r.unstable_declared();
    r.unstable_undeclared();              //~ ERROR use of unstable library feature

    r.pub_crate();                        //~ ERROR `pub_crate` is private
    r.pub_mod();                          //~ ERROR `pub_mod` is private
    r.private();                          //~ ERROR `private` is private

    // Repeat tests for tuple struct
    let t = Tuple::new();
    t.stable_trait_method();
    t.unstable_declared_trait_method();
    t.unstable_undeclared_trait_method(); //~ ERROR use of unstable library feature

    t.stable();
    t.unstable_declared();
    t.unstable_undeclared();              //~ ERROR use of unstable library feature

    t.pub_crate();                        //~ ERROR `pub_crate` is private
    t.pub_mod();                          //~ ERROR `pub_mod` is private
    t.private();                          //~ ERROR `private` is private
}