Page MenuHomePhabricator
Differential D13124

[native] Fix broken StyleProps type for react-native-reanimated libdef
ClosedPublic
Actions

Authored by ashoat on Aug 20 2024, 9:58 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 16, 10:49 AM
Unknown Object (File)
Wed, Apr 16, 7:55 AM
Unknown Object (File)
Tue, Apr 15, 10:57 PM
Unknown Object (File)
Mon, Apr 14, 10:58 PM
Unknown Object (File)
Wed, Apr 9, 12:13 PM
Unknown Object (File)
Tue, Apr 1, 6:27 AM
Unknown Object (File)
Mar 4 2025, 9:25 PM
Unknown Object (File)
Feb 19 2025, 3:36 AM
View All 66 Files
Subscribers
None

Details

Reviewers
inka
tomek
Commits
rCOMMfc35683c9ffa: [native] Fix broken StyleProps type for react-native-reanimated libdef
Summary

This issue was first introduced in D5556, and led to a $FlowFixMe being introduced in D13066.

It's not possible to spread a non-object. I remove the spreads here because the only relevant part of the union is the object form ({ [name: string]: any, ... }), which is already included in the StyleProps type anyways.

This diff addresses part of ENG-9039.

Test Plan

Flow

Diff Detail

Repository
rCOMM Comm
Branch
ashoat/flow
Lint
No Lint Coverage
Unit
No Test Coverage

Revision Contents
Changeset List

PathSize
native/
flow-typed/
npm/
2 lines
tooltip/
1 line

Diff 43524

View Options

native/flow-typed/npm/react-native-reanimated_v2.x.x.js

#[cxx::bridge] #[cxx::bridge]
mod ffi { mod ffi {
extern "Rust" { extern "Rust" {
fn rust_is_initialized_cxx() -> bool; fn rust_is_initialized_cxx() -> bool;
fn rust_initialize_cxx() -> (); fn rust_initialize_cxx() -> ();
unsafe fn rust_process_cxx(_: *const c_char) -> (); unsafe fn rust_process_cxx(data: *const c_char) -> ();
fn rust_terminate_cxx() -> (); fn rust_terminate_cxx() -> ();
} }
} }
mod constants; mod constants;
use constants::MPSC_CHANNEL_BUFFER_CAPACITY; use constants::MPSC_CHANNEL_BUFFER_CAPACITY;
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use tokio::sync::mpsc; use tokio::sync::mpsc;
use tokio::task::JoinHandle; use tokio::task::JoinHandle;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
extern crate libc; extern crate libc;
use libc::c_char; use libc::c_char;
use std::ffi::CStr;
pub struct Client { pub struct Client {
tx: Option<mpsc::Sender<String>>, tx: Option<mpsc::Sender<String>>,
handle: Option<JoinHandle<()>>, handle: Option<JoinHandle<()>>,
} }
lazy_static! { lazy_static! {
pub static ref CLIENT: Arc<Mutex<Client>> = Arc::new(Mutex::new(Client { pub static ref CLIENT: Arc<Mutex<Client>> = Arc::new(Mutex::new(Client {
Show All 25 Lines let handle = RUNTIME.spawn(async move {
} }
println!("[RUST] [receiver] done"); println!("[RUST] [receiver] done");
}); });
CLIENT.lock().expect("access client").handle = Some(handle); CLIENT.lock().expect("access client").handle = Some(handle);
CLIENT.lock().expect("access client").tx = Some(tx); CLIENT.lock().expect("access client").tx = Some(tx);
println!("[RUST] initialized"); println!("[RUST] initialized");
} }
pub fn rust_process_cxx(_: *const c_char) -> () { pub fn rust_process_cxx(data: *const c_char) -> () {
unimplemented!(); println!("[RUST] [rust_process] begin");
let c_str: &CStr = unsafe { CStr::from_ptr(data) };
let str: String = c_str.to_str().unwrap().to_owned();
tomekUnsubmitted
Not Done
Inline Actions

Using str as a name sounds confusing. Can we use a name that isn't also a type name?

tomek: Using `str` as a name sounds confusing. Can we use a name that isn't also a type name?
karolAuthorUnsubmitted
Done
Inline Actions

sure, whatever

karol: sure, whatever
println!("[RUST] [rust_process] data string: {}", str);
// this works
tomekUnsubmitted
Not Done
Inline Actions

I guess we can remove this

tomek: I guess we can remove this
karolAuthorUnsubmitted
Done
Inline Actions

right

karol: right
RUNTIME.block_on(async {
CLIENT
.lock()
.expect("access client")
.tx
tomekUnsubmitted
Not Done
Inline Actions

Does that mean that we can write only from one thread at a time? Doesn't sounds like an issue, just wanted to clarify.

tomek: Does that mean that we can write only from one thread at a time? Doesn't sounds like an issue…
karolAuthorUnsubmitted
Done
Inline Actions

yes

karol: yes
.as_ref()
.expect("access client's transmitter")
.send(str)
.await
.expect("send data to receiver");
});
println!("[RUST] [rust_process] end");
} }
pub fn rust_terminate_cxx() -> () { pub fn rust_terminate_cxx() -> () {
unimplemented!(); unimplemented!();
} }
View Options

native/tooltip/nux-tips-overlay.react.js

#[cxx::bridge] #[cxx::bridge]
mod ffi { mod ffi {
extern "Rust" { extern "Rust" {
fn rust_is_initialized_cxx() -> bool; fn rust_is_initialized_cxx() -> bool;
fn rust_initialize_cxx() -> (); fn rust_initialize_cxx() -> ();
unsafe fn rust_process_cxx(_: *const c_char) -> (); unsafe fn rust_process_cxx(data: *const c_char) -> ();
fn rust_terminate_cxx() -> (); fn rust_terminate_cxx() -> ();
} }
} }
mod constants; mod constants;
use constants::MPSC_CHANNEL_BUFFER_CAPACITY; use constants::MPSC_CHANNEL_BUFFER_CAPACITY;
use tokio::runtime::Runtime; use tokio::runtime::Runtime;
use tokio::sync::mpsc; use tokio::sync::mpsc;
use tokio::task::JoinHandle; use tokio::task::JoinHandle;
use lazy_static::lazy_static; use lazy_static::lazy_static;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
extern crate libc; extern crate libc;
use libc::c_char; use libc::c_char;
use std::ffi::CStr;
pub struct Client { pub struct Client {
tx: Option<mpsc::Sender<String>>, tx: Option<mpsc::Sender<String>>,
handle: Option<JoinHandle<()>>, handle: Option<JoinHandle<()>>,
} }
lazy_static! { lazy_static! {
pub static ref CLIENT: Arc<Mutex<Client>> = Arc::new(Mutex::new(Client { pub static ref CLIENT: Arc<Mutex<Client>> = Arc::new(Mutex::new(Client {
Show All 25 Lines let handle = RUNTIME.spawn(async move {
} }
println!("[RUST] [receiver] done"); println!("[RUST] [receiver] done");
}); });
CLIENT.lock().expect("access client").handle = Some(handle); CLIENT.lock().expect("access client").handle = Some(handle);
CLIENT.lock().expect("access client").tx = Some(tx); CLIENT.lock().expect("access client").tx = Some(tx);
println!("[RUST] initialized"); println!("[RUST] initialized");
} }
pub fn rust_process_cxx(_: *const c_char) -> () { pub fn rust_process_cxx(data: *const c_char) -> () {
unimplemented!(); println!("[RUST] [rust_process] begin");
let c_str: &CStr = unsafe { CStr::from_ptr(data) };
let str: String = c_str.to_str().unwrap().to_owned();
tomekUnsubmitted
Not Done
Inline Actions

Using str as a name sounds confusing. Can we use a name that isn't also a type name?

tomek: Using `str` as a name sounds confusing. Can we use a name that isn't also a type name?
karolAuthorUnsubmitted
Done
Inline Actions

sure, whatever

karol: sure, whatever
println!("[RUST] [rust_process] data string: {}", str);
// this works
tomekUnsubmitted
Not Done
Inline Actions

I guess we can remove this

tomek: I guess we can remove this
karolAuthorUnsubmitted
Done
Inline Actions

right

karol: right
RUNTIME.block_on(async {
CLIENT
.lock()
.expect("access client")
.tx
tomekUnsubmitted
Not Done
Inline Actions

Does that mean that we can write only from one thread at a time? Doesn't sounds like an issue, just wanted to clarify.

tomek: Does that mean that we can write only from one thread at a time? Doesn't sounds like an issue…
karolAuthorUnsubmitted
Done
Inline Actions

yes

karol: yes
.as_ref()
.expect("access client's transmitter")
.send(str)
.await
.expect("send data to receiver");
});
println!("[RUST] [rust_process] end");
} }
pub fn rust_terminate_cxx() -> () { pub fn rust_terminate_cxx() -> () {
unimplemented!(); unimplemented!();
} }