1use super::*;
2
3impl Writer {
4 pub fn write_core(&self) -> TokenStream {
5 if self.config.sys {
6 if self.config.package || !self.config.no_core {
7 quote! { windows_sys::core:: }
8 } else if self.config.flat {
9 quote! {}
10 } else {
11 let mut tokens = TokenStream::new();
12
13 for _ in 0..self.namespace.split('.').count() {
14 tokens.push_str("super::");
15 }
16
17 tokens
18 }
19 } else {
20 quote! { windows_core:: }
21 }
22 }
23
24 pub fn write_generic_phantoms(&self, generics: &[Type]) -> TokenStream {
25 if generics.is_empty() {
26 quote! {}
27 } else {
28 let generics = generics.iter().map(|ty| ty.write_name(self));
29 quote! { #(core::marker::PhantomData::<#generics>),* }
30 }
31 }
32
33 pub fn write_generic_named_phantoms(&self, generics: &[Type]) -> TokenStream {
34 if generics.is_empty() {
35 quote! {}
36 } else {
37 let generics = generics.iter().map(|ty| ty.write_name(self));
38 quote! { #(#generics: core::marker::PhantomData::<#generics>),* }
39 }
40 }
41
42 pub fn write_generic_constraints(&self, generics: &[Type]) -> TokenStream {
43 if generics.is_empty() {
44 quote! {}
45 } else {
46 let generics = generics.iter().map(|ty| ty.write_name(self));
47 quote! { #(#generics: windows_core::RuntimeType + 'static,)* }
48 }
49 }
50
51 pub fn write_namespace(&self, type_name: TypeName) -> TokenStream {
52 let mut tokens = TokenStream::new();
53
54 if type_name.namespace().is_empty() {
55 return tokens;
56 }
57
58 if let Some(reference) = {
59 if self.config.types.contains_key(&type_name) {
60 None
61 } else {
62 self.config.references.contains(type_name)
63 }
64 } {
65 tokens.push_str(&reference.name);
66 tokens.push_str("::");
67
68 if reference.style == ReferenceStyle::Flat {
69 return tokens;
70 }
71
72 let mut namespace = type_name.namespace().split('.').peekable();
73
74 if reference.style == ReferenceStyle::SkipRoot {
75 namespace.next();
76 }
77
78 for namespace in namespace {
79 tokens.push_str(namespace);
80 tokens.push_str("::");
81 }
82
83 tokens
84 } else {
85 if self.config.flat || type_name.namespace() == self.namespace {
86 return tokens;
87 }
88
89 let mut relative = self.namespace.split('.').peekable();
90 let mut namespace = type_name.namespace().split('.').peekable();
91
92 while relative.peek() == namespace.peek() {
93 if relative.next().is_none() {
94 break;
95 }
96
97 namespace.next();
98 }
99
100 for _ in 0..relative.count() {
101 tokens.push_str("super::");
102 }
103
104 for namespace in namespace {
105 tokens.push_str(namespace);
106 tokens.push_str("::");
107 }
108
109 tokens
110 }
111 }
112}
113