Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ca2175d3 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge changes from topic "aconfig-codegen-ownership" into main 

* changes:
  aconfig: pass ownership of ProtoParsedFlag items to Java codegen
  aconfig: pass ownership of ProtoParsedFlag items to C++ codegen
  aconfig: pass ownership of ProtoParsedFlag items to Rust codegen
parents ecabf893 0c6a2fac

tools/aconfig/src/codegen/cpp.rs

+9 −6
Original line number Diff line number Diff line
@@ -23,17 +23,17 @@ use crate::codegen; 
use crate::commands::{CodegenMode, OutputFile};

use crate::protos::{ProtoFlagPermission, ProtoFlagState, ProtoParsedFlag};



pub fn generate_cpp_code<'a, I>(

pub fn generate_cpp_code<I>(

    package: &str,

    parsed_flags_iter: I,

    codegen_mode: CodegenMode,

) -> Result<Vec<OutputFile>>

where

    I: Iterator<Item = &'a ProtoParsedFlag>,

    I: Iterator<Item = ProtoParsedFlag>,

{

    let mut readwrite_count = 0;

    let class_elements: Vec<ClassElement> = parsed_flags_iter

        .map(|pf| create_class_element(package, pf, &mut readwrite_count))

        .map(|pf| create_class_element(package, &pf, &mut readwrite_count))

        .collect();

    let readwrite = readwrite_count > 0;

    let has_fixed_read_only = class_elements.iter().any(|item| item.is_fixed_read_only);
@@ -734,8 +734,11 @@ void com_android_aconfig_test_reset_flags() { 


    fn test_generate_cpp_code(mode: CodegenMode) {

        let parsed_flags = crate::test::parse_test_flags();

        let generated =

            generate_cpp_code(crate::test::TEST_PACKAGE, parsed_flags.parsed_flag.iter(), mode)

        let generated = generate_cpp_code(

            crate::test::TEST_PACKAGE,

            parsed_flags.parsed_flag.into_iter(),

            mode,

        )

        .unwrap();

        let mut generated_files_map = HashMap::new();

        for file in generated {

tools/aconfig/src/codegen/java.rs

+6 −6
Original line number Diff line number Diff line
@@ -24,16 +24,16 @@ use crate::codegen; 
use crate::commands::{CodegenMode, OutputFile};

use crate::protos::{ProtoFlagPermission, ProtoFlagState, ProtoParsedFlag};



pub fn generate_java_code<'a, I>(

pub fn generate_java_code<I>(

    package: &str,

    parsed_flags_iter: I,

    codegen_mode: CodegenMode,

) -> Result<Vec<OutputFile>>

where

    I: Iterator<Item = &'a ProtoParsedFlag>,

    I: Iterator<Item = ProtoParsedFlag>,

{

    let flag_elements: Vec<FlagElement> =

        parsed_flags_iter.map(|pf| create_flag_element(package, pf)).collect();

        parsed_flags_iter.map(|pf| create_flag_element(package, &pf)).collect();

    let exported_flag_elements: Vec<FlagElement> =

        flag_elements.iter().filter(|elem| elem.exported).cloned().collect();

    let namespace_flags = gen_flags_by_namespace(&flag_elements);
@@ -361,7 +361,7 @@ mod tests { 
        let parsed_flags = crate::test::parse_test_flags();

        let generated_files = generate_java_code(

            crate::test::TEST_PACKAGE,

            parsed_flags.parsed_flag.iter(),

            parsed_flags.parsed_flag.into_iter(),

            CodegenMode::Production,

        )

        .unwrap();
@@ -514,7 +514,7 @@ mod tests { 
        let parsed_flags = crate::test::parse_test_flags();

        let generated_files = generate_java_code(

            crate::test::TEST_PACKAGE,

            parsed_flags.parsed_flag.iter(),

            parsed_flags.parsed_flag.into_iter(),

            CodegenMode::Exported,

        )

        .unwrap();
@@ -705,7 +705,7 @@ mod tests { 
        let parsed_flags = crate::test::parse_test_flags();

        let generated_files = generate_java_code(

            crate::test::TEST_PACKAGE,

            parsed_flags.parsed_flag.iter(),

            parsed_flags.parsed_flag.into_iter(),

            CodegenMode::Test,

        )

        .unwrap();

tools/aconfig/src/codegen/rust.rs

+9 −6
Original line number Diff line number Diff line
@@ -22,16 +22,16 @@ use crate::codegen; 
use crate::commands::{CodegenMode, OutputFile};

use crate::protos::{ProtoFlagPermission, ProtoFlagState, ProtoParsedFlag};



pub fn generate_rust_code<'a, I>(

pub fn generate_rust_code<I>(

    package: &str,

    parsed_flags_iter: I,

    codegen_mode: CodegenMode,

) -> Result<OutputFile>

where

    I: Iterator<Item = &'a ProtoParsedFlag>,

    I: Iterator<Item = ProtoParsedFlag>,

{

    let template_flags: Vec<TemplateParsedFlag> =

        parsed_flags_iter.map(|pf| TemplateParsedFlag::new(package, pf)).collect();

        parsed_flags_iter.map(|pf| TemplateParsedFlag::new(package, &pf)).collect();

    let has_readwrite = template_flags.iter().any(|item| item.readwrite);

    let context = TemplateContext {

        package: package.to_string(),
@@ -456,8 +456,11 @@ pub fn reset_flags() { 


    fn test_generate_rust_code(mode: CodegenMode) {

        let parsed_flags = crate::test::parse_test_flags();

        let generated =

            generate_rust_code(crate::test::TEST_PACKAGE, parsed_flags.parsed_flag.iter(), mode)

        let generated = generate_rust_code(

            crate::test::TEST_PACKAGE,

            parsed_flags.parsed_flag.into_iter(),

            mode,

        )

        .unwrap();

        assert_eq!("src/lib.rs", format!("{}", generated.path.display()));

        assert_eq!(

tools/aconfig/src/commands.rs

+6 −3
Original line number Diff line number Diff line
@@ -201,7 +201,8 @@ pub fn create_java_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<Ve 
    let Some(package) = find_unique_package(&filtered_parsed_flags) else {

        bail!("no parsed flags, or the parsed flags use different packages");

    };

    generate_java_code(package, filtered_parsed_flags.iter(), codegen_mode)

    let package = package.to_string();

    generate_java_code(&package, filtered_parsed_flags.into_iter(), codegen_mode)

}



pub fn create_cpp_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<Vec<OutputFile>> {
@@ -210,7 +211,8 @@ pub fn create_cpp_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<Vec 
    let Some(package) = find_unique_package(&filtered_parsed_flags) else {

        bail!("no parsed flags, or the parsed flags use different packages");

    };

    generate_cpp_code(package, filtered_parsed_flags.iter(), codegen_mode)

    let package = package.to_string();

    generate_cpp_code(&package, filtered_parsed_flags.into_iter(), codegen_mode)

}



pub fn create_rust_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<OutputFile> {
@@ -219,7 +221,8 @@ pub fn create_rust_lib(mut input: Input, codegen_mode: CodegenMode) -> Result<Ou 
    let Some(package) = find_unique_package(&filtered_parsed_flags) else {

        bail!("no parsed flags, or the parsed flags use different packages");

    };

    generate_rust_code(package, filtered_parsed_flags.iter(), codegen_mode)

    let package = package.to_string();

    generate_rust_code(&package, filtered_parsed_flags.into_iter(), codegen_mode)

}



pub fn create_storage(caches: Vec<Input>, container: &str) -> Result<Vec<OutputFile>> {