1// Copyright © SixtyFPS GmbH <info@slint.dev>
2// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
3
4/*!
5This module contains the [`NamedReference`] and its helper
6*/
7
8use smol_str::SmolStr;
9use std::cell::RefCell;
10use std::collections::HashMap;
11use std::hash::Hash;
12use std::rc::{Rc, Weak};
13
14use crate::langtype::{ElementType, Type};
15use crate::object_tree::{Element, ElementRc, PropertyAnalysis, PropertyVisibility};
16
17/// Reference to a property or callback of a given name within an element.
18#[derive(Clone)]
19pub struct NamedReference(Rc<NamedReferenceInner>);
20
21pub fn pretty_print_element_ref(
22 f: &mut dyn std::fmt::Write,
23 element: &Weak<RefCell<Element>>,
24) -> std::fmt::Result {
25 match element.upgrade() {
26 Some(e: Rc>) => match e.try_borrow() {
27 Ok(el: Ref<'_, Element>) => write!(f, "{}", el.id),
28 Err(_) => write!(f, "<borrowed>"),
29 },
30 None => write!(f, "<null>"),
31 }
32}
33
34impl std::fmt::Debug for NamedReference {
35 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
36 pretty_print_element_ref(f, &self.0.element)?;
37 write!(f, ".{}", self.0.name)
38 }
39}
40
41impl NamedReference {
42 pub fn new(element: &ElementRc, name: SmolStr) -> Self {
43 Self(NamedReferenceInner::from_name(element, name))
44 }
45 pub(crate) fn snapshot(&self, snapshotter: &mut crate::typeloader::Snapshotter) -> Self {
46 NamedReference(Rc::new(self.0.snapshot(snapshotter)))
47 }
48 pub fn name(&self) -> &SmolStr {
49 &self.0.name
50 }
51 #[track_caller]
52 pub fn element(&self) -> ElementRc {
53 self.0.element.upgrade().expect("NamedReference to a dead element")
54 }
55 pub fn ty(&self) -> Type {
56 self.element().borrow().lookup_property(self.name()).property_type
57 }
58
59 /// return true if the property has a constant value for the lifetime of the program
60 pub fn is_constant(&self) -> bool {
61 self.is_constant_impl(true)
62 }
63
64 /// return true if we know that this property is changed by other means than its own binding
65 pub fn is_externally_modified(&self) -> bool {
66 !self.is_constant_impl(false)
67 }
68
69 /// return true if the property has a constant value for the lifetime of the program
70 fn is_constant_impl(&self, mut check_binding: bool) -> bool {
71 let mut elem = self.element();
72 let e = elem.borrow();
73 if let Some(decl) = e.property_declarations.get(self.name()) {
74 if decl.expose_in_public_api && decl.visibility != PropertyVisibility::Input {
75 // could be set by the public API
76 return false;
77 }
78 }
79 if e.property_analysis.borrow().get(self.name()).is_some_and(|a| a.is_set_externally) {
80 return false;
81 }
82 drop(e);
83
84 loop {
85 let e = elem.borrow();
86 if e.property_analysis.borrow().get(self.name()).is_some_and(|a| a.is_set) {
87 // if the property is set somewhere, it is not constant
88 return false;
89 }
90
91 if let Some(b) = e.bindings.get(self.name()) {
92 if check_binding && !b.borrow().analysis.as_ref().is_some_and(|a| a.is_const) {
93 return false;
94 }
95 if !b.borrow().two_way_bindings.iter().all(|n| n.is_constant()) {
96 return false;
97 }
98 check_binding = false;
99 }
100 if let Some(decl) = e.property_declarations.get(self.name()) {
101 if let Some(alias) = &decl.is_alias {
102 return alias.is_constant();
103 }
104 return true;
105 }
106 match &e.base_type {
107 ElementType::Component(c) => {
108 let next = c.root_element.clone();
109 drop(e);
110 elem = next;
111 continue;
112 }
113 ElementType::Builtin(b) => {
114 return b.properties.get(self.name()).map_or(true, |pi| !pi.is_native_output())
115 }
116 ElementType::Native(n) => {
117 return n.properties.get(self.name()).map_or(true, |pi| !pi.is_native_output())
118 }
119 crate::langtype::ElementType::Error | crate::langtype::ElementType::Global => {
120 return true
121 }
122 }
123 }
124 }
125
126 /// Mark that this property is set somewhere in the code
127 pub fn mark_as_set(&self) {
128 let element = self.element();
129 element
130 .borrow()
131 .property_analysis
132 .borrow_mut()
133 .entry(self.name().clone())
134 .or_default()
135 .is_set = true;
136 mark_property_set_derived_in_base(element, self.name())
137 }
138}
139
140impl Eq for NamedReference {}
141
142impl PartialEq for NamedReference {
143 fn eq(&self, other: &Self) -> bool {
144 Rc::ptr_eq(&self.0, &other.0)
145 }
146}
147
148impl Hash for NamedReference {
149 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
150 Rc::as_ptr(&self.0).hash(state);
151 }
152}
153
154struct NamedReferenceInner {
155 /// The element.
156 element: Weak<RefCell<Element>>,
157 /// The property name
158 name: SmolStr,
159}
160
161impl NamedReferenceInner {
162 fn check_invariant(&self) {
163 debug_assert!(std::ptr::eq(
164 self as *const Self,
165 Rc::as_ptr(
166 &self.element.upgrade().unwrap().borrow().named_references.0.borrow()[&self.name]
167 )
168 ))
169 }
170
171 pub fn from_name(element: &ElementRc, name: SmolStr) -> Rc<Self> {
172 let elem = element.borrow();
173 let mut named_references = elem.named_references.0.borrow_mut();
174 let result = if let Some(r) = named_references.get(&name) {
175 r.clone()
176 } else {
177 let r = Rc::new(Self { element: Rc::downgrade(element), name });
178 named_references.insert(r.name.clone(), r.clone());
179 r
180 };
181 drop(named_references);
182 result.check_invariant();
183 result
184 }
185
186 pub(crate) fn snapshot(&self, snapshotter: &mut crate::typeloader::Snapshotter) -> Self {
187 let element = if let Some(el) = self.element.upgrade() {
188 Rc::downgrade(&snapshotter.use_element(&el))
189 } else {
190 std::rc::Weak::default()
191 };
192
193 Self { element, name: self.name.clone() }
194 }
195}
196
197/// Must be put inside the Element and owns all the NamedReferenceInner
198#[derive(Default)]
199pub struct NamedReferenceContainer(RefCell<HashMap<SmolStr, Rc<NamedReferenceInner>>>);
200
201impl NamedReferenceContainer {
202 /// Returns true if there is at least one NamedReference pointing to the property `name` in this element.
203 pub fn is_referenced(&self, name: &str) -> bool {
204 if let Some(nri: &Rc) = self.0.borrow().get(name) {
205 // one reference for the hashmap itself
206 Rc::strong_count(this:nri) > 1
207 } else {
208 false
209 }
210 }
211
212 pub(crate) fn snapshot(
213 &self,
214 snapshotter: &mut crate::typeloader::Snapshotter,
215 ) -> NamedReferenceContainer {
216 let inner: HashMap> = self
217 .0
218 .borrow()
219 .iter()
220 .map(|(k: &SmolStr, v: &Rc)| (k.clone(), Rc::new(v.snapshot(snapshotter))))
221 .collect();
222 NamedReferenceContainer(RefCell::new(inner))
223 }
224}
225
226/// Mark that a given property is `is_set_externally` in all bases
227pub(crate) fn mark_property_set_derived_in_base(mut element: ElementRc, name: &str) {
228 loop {
229 let next: Rc> = if let ElementType::Component(c: &Rc) = &element.borrow().base_type {
230 if element.borrow().property_declarations.contains_key(name) {
231 return;
232 };
233 match c.root_element.borrow().property_analysis.borrow_mut().entry(key:name.into()) {
234 std::collections::hash_map::Entry::Occupied(e: OccupiedEntry<'_, SmolStr, …>) if e.get().is_set_externally => {
235 return;
236 }
237 std::collections::hash_map::Entry::Occupied(mut e: OccupiedEntry<'_, SmolStr, …>) => {
238 e.get_mut().is_set_externally = true;
239 }
240 std::collections::hash_map::Entry::Vacant(e: VacantEntry<'_, SmolStr, …>) => {
241 e.insert(PropertyAnalysis { is_set_externally: true, ..Default::default() });
242 }
243 }
244 c.root_element.clone()
245 } else {
246 return;
247 };
248 element = next;
249 }
250}
251
252/// Mark that a given property is `is_read_externally` in all bases
253pub(crate) fn mark_property_read_derived_in_base(mut element: ElementRc, name: &str) {
254 loop {
255 let next: Rc> = if let ElementType::Component(c: &Rc) = &element.borrow().base_type {
256 if element.borrow().property_declarations.contains_key(name) {
257 return;
258 };
259 match c.root_element.borrow().property_analysis.borrow_mut().entry(key:name.into()) {
260 std::collections::hash_map::Entry::Occupied(e: OccupiedEntry<'_, SmolStr, …>) if e.get().is_read_externally => {
261 return;
262 }
263 std::collections::hash_map::Entry::Occupied(mut e: OccupiedEntry<'_, SmolStr, …>) => {
264 e.get_mut().is_read_externally = true;
265 }
266 std::collections::hash_map::Entry::Vacant(e: VacantEntry<'_, SmolStr, …>) => {
267 e.insert(PropertyAnalysis { is_read_externally: true, ..Default::default() });
268 }
269 }
270 c.root_element.clone()
271 } else {
272 return;
273 };
274 element = next;
275 }
276}
277