.Net Foundation Design Reviews, 23 Apr 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: .NET Design Review: GitHub Quick Reviews (Apr 23)

Description

00:00:00 - Approved: Add DynamicallyAccessedMembersAttribute https://github.com/dotnet/runtime/issues/33861#issuecomment-618548274
00:48:15 - Approved: Add SuppressLinkerWarningAttribute https://github.com/dotnet/runtime/issues/35339#issuecomment-618570506
01:24:22 - Approved: Consider PreserveDependencyAttribute to help linker https://github.com/dotnet/runtime/issues/30902#issuecomment-618601805

A

B

Hello friends, so today we are going to do a few issues regarding linker stuff and then I think this one GC feature and then hopefully yeah exactly there's one thing on we'd only span overloads and compare info and then I think it's backlog. So we have like five or six issues, I believe. So how about this? Who wants to do the work through flu linker.

C

B

This way, I can.

C

Go to a presentation: okay, we can go through the slides, because they're not slides, give you your motivation for what we're trying to don't like the API itself is not very interesting.

C

um So what what we are trying to do with the linker is that the purpose of the linker is to make up smaller by stripping unused code, and it's kind of well known that it has problems with reflection, because it's really hard to find things that truly unused and I have an example.

C

There, where you can just like activate a create instance, type that you can download the string from the internet, and you know now for us, it's more important than ever to be able to make ups small, because we were simply scanning to.net and also the marine is switching to that net. Core, so kind of let's test the problem and the main problem is really the conflict between a small app and a working app like. If you enable ring linker- and you don't have a good idea, what kind of reflection will be inside?

C

It's very well possible that after winking and removing any of skulls, your app stops working because some of the code was actually used so in dot, not core 3.0. We shipped linker as an opt-in option in a very conservative mode, kind of the very conservative mode. Didn't touch user assemblies at all. We would entire framework assemblies if they appeared unused and kind of it didn't try to remove individual types or methods.

C

Oh, we got kind of dissing site size savings, but they are not quite as critical as they could be, and even this very conservative mode managed to break some some apps. Sometimes so the experience is not great and I know we were thinking. Can we do it better? So the next slide you can.

C

So we were talking starting to think about linkers safety ah kind of how can being give guarantees to the customers that our linker will not break their abs.

C

The experience right now is that we ask customers to kind of read us the entire app, but that's very frustrating, and whenever you make a change to your earth, you could have accidentally removed something and that reflection stops working because their function was relying on some some code, part keeping something that to mean that the the bad thing about this is really that it's not unique testable because if you run the linker on ionic past and now, basically the link I, don't think the different parts of the app are used.

C

So you know it like you really need to out to make it somehow I know, that's that's the direction that we took. We go to the next slide.

C

So we were started starting to think about okay. How do we automate this and we started with bringing all the pieces of reflection analyzer from MIT that is able to analyze all the using sister play of a fraction in code? If, if you have something within a metal- and it's not doing something to complicate that, then link actually just figure it out and it should be able to kind of see through the reflection patterns in there.

C

We also said that whenever analyzer within the linker won't be able to figure things out, it will warn that some, you think, compared to the negative. The warnings are not there, because there will be too much nice.

C

We came up with some annotations to help linker analyze things better, and we would also like to come up with suppressions for some of the warnings that could be or things that are actually fine. You.

B

Can ask a quick.

C

Question here see.

B

When you say warnings to who will see the one is the analyzer for our own code or unless it's something that the customer runs.

C

So it will be possible to run it both on individual assemblies or on the entire app during publishing. Oh kind of I. I would like it to be enabled within Co effects built as well, so that we can see those working as well and.

B

I guess the warnings are basically for you. You have annotations that are not sufficient. Yes,.

C

Like that, is this either a notation that is not sufficient or just like some crazy reflection news that cannot be reasoned about statically I will have some examples: okay, I'm just yeah.

C

Maybe we can go to the next slide, so these are kind of the easy cases that we are enabling like if, within the method, do you have code like this, it should be possible to statically analyze that we need to keep default constructors. We need to keep an extra method. We need to keep an extra field, the kind of that's something that we will enable, so that you don't need to annotate too much, but in a real world call this almost never like this.

C

So you know that's why we also need some annotations to kind of help. The linker you can have the next slide. Maybe.

C

So the question was really: what should we do when there is some instant reflection pattern that is not visible within a single metal body and like how do we make sure that that kind of reflection can still be safe and we can kind of provide actionable warnings?

C

So the thing that we came up with is a way to attach annotations to locations of type C standard type within the code base, and that annotation would specify some kind of demand on the value that is being stored into a new location or give it some like extra capability or annotation.

C

Whenever it's loaded, a kind of you can annotate, let's say a field parameter on a method and say that whenever you store a system type to this location, that system type needs to have all the methods kept, for example, or all the all the customer or all the instructor script, or all the fields kept and kind of the linker can reason about this, and it can see that like, for example, we have a type of within the app and then you store it into a location like this.

C

So you kind of pass it to a method that says like whenever you give me a system, the type I need all the constructors.

C

A kind of blinker can reason about something like this and it can kind of make sure that these things happen so kind of you either need to pass it something that is known. So it's either. It comes from time to time with a non string, but it comes from a type of or work. It comes from some other location that is annotated the right way, and whenever this doesn't happen, it can warn maybe next slide.

C

Is just a really quick example of like how the data flow through many things would look like, but we have a field of type system that type that is annotated with this custom attribute that we are proposing and the annotation is saying, is like these types will always have all the methods kept and then within the app we can see that there is a store into this location and the stories with a known value, because we can see there is a type of good time with that non string.

C

It's something that the linker can reason about. So whenever it sees this kind of store, it will just kind of keep the type and it will keep all the methods on it. And then we have another location within the program where we load from this field and call some reflection, API and since this location was annotate, that we know that this reflection, API call is safe and if the annotation wasn't there, then now kind of linker has no idea what this is.

C

What is it operating on that, like the method can be character, whether it's not kept, so it would issue a warning, but because the allocation was annotated, it knows that this operation is safe. So.

B

Basically, that means now, if within the type program, if I now would use other type to access properties of fields where reflection, then that means I did not get meditations correct.

B

C

B

Basically, the the other type field is marked with saying: okay, I will I will use this type to access methods, potentially so keep all the methods and if I would know it within the program type, if I would know access properties or fields or events. That means I just got my annotations wrong right. So now that would.

C

B

Potentially those things and then I would be screwed right. Yes,.

C

B

So that's, why see what I was getting it so a days that the analyzer would give me, then warnings when it sees accesses to other type, I ask for events or fields, because annotations say that I'm not doing that? Yes,.

C

Yes, those annotations don't guarantee that it will be kept or actually for properties. It would actually work because kind of all the methods on the time, but also the tinkles protect the accessories, which means we keep also the properties but yeah. That's that's the general idea.

C

Oh maybe connect slide and then the last part that we would like to think about this warning suppression. So sometimes we know that something is safe and kinda. We can guarantee that, but it's not obvious to the linker and they're like we couldn't come up with a good way to annotate it and that's.

C

For example, if we place an annotated system to type into a list, and then we take it out of the list, you know we know that whatever we put into the list was annotated, so kind of the load should also be resulting in like an annotated value, but the linker will not know that, and it would normally issue a warning that, like hey, you got system type I, don't know where you got it from and like you're, trying to access methods on it or trying to do something with it and I cannot guarantee you that those things will work.

C

Okay. No, for that, you would like to come up with some suppression attribute where you can suppress the specific warning and just studied it like this. This operation is fine. You.

C

The last thing is that, like this, of course, doesn't work for all reflection, and there are some patterns that are never compatible with Winker and that's kind of like I have I have got somewhere. That is just reading. Some string from the internet and just like activating a random type kind of those will never be safe. Linker will always warn for them, and it would be nice if, for example, library developer will be able to annotate. Their API did like this specific API is not linker, safe, so kind of.

C

If you are running on a shaker like the dial linker, don't call into this API and then could there could be some kind of message or something that helps say that like yeah- and this is not safe like we have some other VI or something you can use instead, for example, I have.

D

A question on this slide does: does this imply that if I'm, a library, author and I use these patterns, I additionally have to annotate my module with these attributes or that the linker can identify these patterns and automatically assume that I have that attribute and.

C

So linker will not do those things for you. You have to annotate that it's kind of like the nullable annotations and in c-sharp like when a logo came out. You you have to unload everything manually like the compiler will tell you, will give you all the warnings as well as will tell you where you have to put them, but what you have to actually do the action of and place those annotations.

A

D

A

Think that the experience will be slightly different, like the experience will be that the linker will see into the library and we'll find that you're using the pattern there and if it's not like fixed in the library I cannot get it correctly and it doesn't leak out. Then it would say nothing, but if it leaks out through whatever means or it's not annotated, then you would get a warning. The difference would be that in this case you will get a warning about some internal assets in the library. So the experience is not great.

A

If you put the attribute on the entry point, you would instead get that which could be like nice message, which is like domain-specific grade.

D

Just to clarify, then, if I, if I'm, if I, have a library that uses one of these patterns and I pull it into my own application, say that the library was created five ten years ago. So it's not going to have this attribute. What's the behavior that my application would have when it pulls in such a library.

A

When you're under linker, the linker will issues some warnings from within the library.

D

Okay and those so who's the target audience for this very specific attribute of the library component. That's using these patterns.

A

It's kind of combination we needed ourselves because there are certain methods in our reflection which are simply unsafe, like assembly that get types so you'd put it there, but also you can use it on the library basically say you know whatever is behind this. Api is not linked or safe. Please don't call this and.

D

And you anticipate that the number of libraries with her under active development, so people were pushing out new versions in 2020, is high enough to make this attribute worthwhile.

D

Because I clearly can't apply this attribute to an existing already shipped library, because.

A

D

Don't own the source code to it, I can't recompile. Yes,.

A

And that's not necessarily required, you would still get a warning. It just wouldn't be as nice right, sir, if you put it on a if you use it on a code which is not safe, linker will Warren. The question is: what will do what will be the message you get current.

D

A

D

Sir the reason behind these questions is I was trying to figure out who the target audience for applying these attributes was. If the target audience is people who have already shipped libraries. Well, we can't ship a new API for them, because they've already compiled their code. If the target audience is us internally, does the attribute have to be public and, and so on, I see it's a conversation that we can have later. I just wanted to kind of speed. That discussion are.

E

We talking about specifically there requires, on reference code attribute on the side. Are you talking about all the attributes? This slides specifically.

A

All right, I think we need it publicly, but it's a in fact for them for the public usage, it's mostly about like having a better experience with a library and also like you know, xamarin or blazer, we'll use this or like the higher level frameworks. We'll use this right. So then the question becomes like: should we keep it sort of internal and internalize them internalize it for them as well? Or could we make it public.

B

I mean we should only go through the slides before we make any judgment, but the way I understand it is like if we assume that nullable would be not a c-sharp feature, inaudible would have done and aesthetic code analysis feature. Then that would be. You know similar to your experience where you get warnings, but the warnings are now inside of the library rather than at the entry points to set library right.

B

So basically, the consumers of the library has the worst experience unless the author of the library entertains the entry points, but the feature will also work when the library also didn't annotate the entry points right. So I guess that's why it needs to be public, because the idea is that library, authors holistically buy into this model and annotate the libraries to be linked are safe and then consumers have said library will basically have a better experience.

A

Yet the steady.

B

Okay, that was into this lecture boss, alright,.

B

We should look at them this one here.

C

You know, I would probably start with this one so kind of this. This is the annotation to put on the system type. We would also like to enable putting it on standard string locations, but it's not like a night API review thing, because you cannot specify what types these are here it should be placed on, but whenever you're placing on system that string, the expectation would be that this is a fully qualified type name and that kind of helps in a bunch of places where people pass around the string and then type to the type.

C

That's fing, it's it's common and after it's probably worth it so.

B

Basically, it is, it would generally apply to variables, you know, field properties and so on of type system to type or system that string.

C

B

C

If it's, if it's system the type done Mike, it's obviously the type that we talked about, if it's system that string that done blinker would assume that it's a fully qualified type name so kind of whenever it sees a string literal, it would interpret it as a fully qualified type name and then do stuff with it right.

B

So then it gets my question that you use. Does it mean that when you see system, though type you assume runtime reflection is going on.

C

Oh, so at that point, linker wouldn't assume anything yet so this is. This is just an annotation that helps and the consumption side whenever you call some reflection API, because the thing within the linker is that if you already have a system to type instance, then that type by definition wasn't stripped right. But it doesn't tell you anything about the members of the type, because all the members are eligible for stripping when aggressive modes are enabled right.

E

C

Kind of that's why most IP is called on. System type are potentially unsafe and you can ask for a base type, that's safe, but if you ask for a method or a field, we don't know whether you will get taken now or whether it will work right.

B

I guess what I'm getting at is so we have this thing called metadata load context where you can instantiate the reflection object model over metadata that you read from a file which wouldn't be runtime reflection right. So that's.

E

B

Would somebody do who has a library that does that, for example, imagine we have a library in our world where the losses to diff API surfaces right, so we built this library in the library. Of course, you know, expose the systems or types and member infos everywhere, but none of them are runtime reflection they all effectively. Just would be. You know what the runtime reads for metadata. That was, you know, passed to it so with some annotated library and say that there's no reflection going on here. So so, don't don't don't worry about it? Yes,.

C

The suppression mechanism, because kind of the linker has no way to distinguish between my system, the type that is the real runtime type or like one of these made-up things. That's in.

B

Place you can also not.

C

Not strip, for example, you can not, you can choose not to run link, then you don't have the problem at all right. All you have to suppress warnings.

B

Like how they get so hot is suppressions didn't work is that is that done with this attribute as well? Oh, is that a completely different mechanism, then.

C

That's that sound different attributes- I, don't I I just made the issue holders, so it's probably not on the radar, but they seem you should include it. Timmikins.

C

And I also Incendia the link to that, because we're like that sounds like something that we should review together with this and.

B

So when I, when I put this attribute on the property and I say, for example, methods does that mean public and private methods, or does it mean public methods only.

C

So there is an enum below lesson that specifies what I tried to match the enum to how binding plugs work. So that's the dynamic, the access number kinds in a bit field and I say.

B

Yeah I see the I, see the member Kenz I'm, trying to make sense of the you know. You have public methods and you have methods does that that methods no mean public and private effectively. Oh yes,.

C

Yes, basically trying to separate into the two categories, because reflection: api's always have one simple: oh well, yes, just say get method and give it one sting and that one only searches for public so kind of this is trying to optimize for that and have encoding for the kind of most common reflection api. Because then you have the other reflection, ideas that take a string and a binding flags, and then you can say also look for non private or something and kind of that. That's why there is this distinction so that we can.

C

You can keep fewer things if you are only calling the the simpler reflection ate the ice yeah.

D

I think this is actually backward normally on binding flags. You explicitly specify non public, so the idea is just take methods. For instance, the idea is, if I said, methods I would expect only public methods to qualify. If I said non public methods, then I would also expect private protected and internal to qualify. So my feedback.

C

D

Be to flip what those flags mean actually and to have methods and non public methods, as opposed to methods in private methods, because non public is a wider net to catch those methods.

E

Kind of make it sound like all methods, though including.

D

Property getters and setters well.

E

Just if you just say methods, doesn't it just kind of feel like all methods like? Why does that? Why does that implicitly imply public yeah.

B

I mean this: is this respectable even earlier I said right, it's the reflection default right. If you say reflection, you know get method, for example, and you pass it a name for private method, able excite you anything. Unless you use too long or overload, we can pass and binding. Flexin also opt in for private state I. Think in general, like people don't think of private state by default right, because if I have effect over something, then you know it's seasonable that it started with public API service right. The.

D

Reason, for that is the the target audience for reflection, is I need to I need to call this API that I don't necessarily know what the type is at compile time. So it's a runtime check, but private methods by definition or implementation, details that the type author did not intend to expose to arbitrary callers. That's why, in the reflection surface, we explicitly make you pass in a flag saying non-public, like I, intend on calling an implementation detail. Please don't stop.

D

Like serializers, for instance, most serializers would never call implementation details, they only care about public reflection.

D

E

F

If you were just using reflection for a forward reference into an assembly, you don't want to, you wouldn't want the linker to keep all private members around you'd want it to be able to still tree shake them. Based on you know, they were just an assert method for.

E

Sure we need the two different ones I'm, just saying, if you just say methods, does it feel like that? That means all methods.

D

Well, from a linker perspective, it's going to be everything anyway right now,.

E

D

What you just said, no, no is so if I'm, if I'm telling the linker I want all public methods to stay there, presumably all the private methods would come along for the ride too, because why does a public? Why does a private method not exist if it's not being called by one of the public api's? If.

F

It was flagged with conditional debug, it's still there in the release, build, but if nothing ever called it and it would be dropped out of by the linker.

E

Okay kind of the point that I was driving towards is, is that specifically the naming part right. You said if I told the linker to save all public methods, it's like well, no, really what you're telling the linker is save methods, and that implies public methods right like it. It just feels to me. It just feels a little bit of a trick to just say method, and it doesn't mean all methods. It only means public methods. Yes,.

D

But I seem surprising to someone who uses the reflection, api's I, think yeah.

G

I think you specify the visibility and all of them just have public methods and non public for.

A

All all methods, public I, think a good example is that if you call time don't get methods it would map to public methods in this you know right.

F

A

That's kind of the country of park.

G

Yeah, but at the same time, it's also a little counterintuitive that type to get methods only returns. A subset I agree.

D

No I disagree with that statement like it's. The point of using reflection in that capacity is to call something that you normally would have been able to call that you don't necessarily know what it is until run. Time says.

G

D

How we've traditionally used reflection like look through the framework? Look through colors, it's very rare, it's very rare, to call an implementation detail of a method unless you also own the implementation type. That's.

G

Fine, but that doesn't change the fact that if I ask you how many methods are on this type- and you only tell me about a subset of them- that's very strange.

D

But you didn't ask how many methods are on the type you asked me to call no.

G

No, if I just say type get methods, I didn't say anything about what successful. It's a fact that we implicitly imbued that with an opinion to only return a subset of them. Never.

D

Should it should it also return the finalizar? Should it return the constructor like it's, not returning all methods also.

G

F

I mean the point: was the not the historical precedence? It's the intuitive us I. Think that's what Steve's commenting on, but.

B

It would stay I, don't know. I I agree with Levi is that the thing is reflection has a use case right and I. Think the vast majority of people doesn't don't reason about private state.

G

What is the downside to including the visibility on all the man things here like having public fields and non public fields, public methods and non public methods rather than methods and non public methods? I? Don't.

D

Have any problems without no.

B

That one seems fine like I would just I would just say we should not have methods, meaning all, because that means the vast majority people will use methods and then effectively pin private state, which they probably didn't, intend.

E

So Steve are you, are you saying we should split it till one? Doesn't isn't a superset of the other one by.

G

The way you I'm late, I apologize but I'm, just looking at what's on the screen right now and there's methods and public methods and I'm suggesting that, yes, they are non-overlapping. So there are public methods and non-public methods, and if you want both, you specify public methods or non public methods just like in reflection today. If you want both instance and static, you specify instance or static or.

E

Public and non-public, you have to put public right.

E

That would definitely more align it with how we're doing reflection, I guess.

B

I mean binding flex is not necessarily great API. No, but yeah I mean I, get it. I would agree with you that it aligns it more I mean I'm personally fine with public methods in private methods. I'm also fine with saying you just have methods and then, as probably, can private as different flags that also works.

B

D

My my feedback on that would be used to termed on public instead of private, because non-public implies more than just private yeah.

B

D

The same Jake because yeah probably.

B

God's the means protected right, but yeah.

D

Yeah, really, you want no.

F

Actually, no, no, it doesn't okay public.

A

Is really what you want is public.

F

Externally, visible and non externally visible, but we don't use the term externally visible in reflection, yeah.

B

I would probably still stick with the binding site emoji, which is basically there's public and non-public, right and public means protected as well and binding Flags land.

D

It doesn't, the public does not imply protected in binding flags land. Instead, what happens is if you, from a linker perspective, if you're keeping public methods and one of them would tree shake such that a protected method happens to remain around then? Yes, you can call that.

D

A public public means quite literally public, and only public in reflection, land.

B

F

Should do it with the same semantics, yeah, whatever those myths are yeah.

D

I'm I'm very sure the public means public and only public. Yes,.

A

It is, we tested it recently.

A

And it's just a note on properties and events. It's a bit weird. What public means is one of the accessors is public right, but necessarily box.

B

You you so it's the consensus that, instead of having methods, we have basically public methods and non public methods. Is that fair.

E

And then we have to change the values as well. Yeah.

A

E

Non-Public methods wouldn't get the public methods bit flipped, align it to Hispanic flex, right right.

G

E

I'm fine with that, if we're voting, I guess.

D

You yeah what I'm, what I'm trying to figure out is what the behavior would be if someone passed in non-public and didn't pass in public as a flag to this API.

E

It would mean exactly what you think it would mean right, all the non-public ones are preserved and any non called public ones could get trimmed.

E

F

I mean if you're gonna reflect jump past a public method. Then it doesn't need it anymore.

D

If you cared about that scenario, you probably care about keeping only one or two very specific methods around to be perfectly honest, and if there was a way to do that, which I think per the slides there was then I would probably honestly use that attribute. Instead of this one.

C

So the specific methods- you cannot rotate it with this, this kind of flow semantics that you can flow the type through the system and pass it around and then, by the time you try to call the wicked method on it. The linker would know that, like oh, this one specific method was kept. Maybe we don't have a way to express that so kind of. If you just want one specific method, you either have to do all the reflection within a single method body so that the linker can see it.

C

You know a linker can see that like, oh, that there was a type of, and then you call on this one specific method, and you are looking for that and it will keep that one specific method. But if, if you want to kind of pass it around, then anyway, I don't think there is a good way how to annotate things like that. If.

E

You knew the specific type in method you could use preserve dependency, which I don't know for reviewing it here, but it's another proposal. I think it was on email.

C

Yes, yes, but that one doesn't have the warning part and the safety part so kind of I I. Don't try to keep it as a separate thing. It will be revealed today. Hopefully, yes,.

B

Its third one in the tabs right now great.

E

And that one's more static, it's this type, this method, where this one it's like the type, can be a bunch of different types dynamically.

E

E

But but it does kind of bring a question like we're: putting a pretty pretty large we're casting a pretty large net right like I need one method, one public method, but I can only say all public methods right.

E

Are we okay with not making it more granular than this I.

D

If I were consuming, something like this I would want the ability to specify granular but I, don't know if I would use this attribute for it. I would use a different attribute, most likely.

B

I think it depends on what you're writing right. If you had a CEO Lizer, for example, you would just say public properties and you literally don't care which one's right anything is permissible, because you just you, don't care about specifics. You just match them. Based on input against methods is different because methods you clearly have to have a knowledge. What you have to pass in for those guys right, so there's polling and expectation that you find specific methods. You may not know whether the method exists.

B

You may do pattern matching or something, but you probably know that you're looking for particular names, XY and Z booth particular set of parameters right yeah,.

D

An example of that would be like a plug-in framework model like I'm.

E

D

A very particular entry point to this type and then once I find it shake out everything I don't care about, but.

E

Like serializable right, like the get serialization info, yes,.

B

That's a good who's know best.

C

Like from family enumeration, that is here, the dynamic we access member kinds, I think the most valuables are the the constructor related ones, and the field and property really delighted ones right, because constructors is like that's that's the major thing that people do with reflection like they will activate a nuclear instance, something that came from somewhere else. Okay, that's the highest value that I, see and then kind of fields and properties. It's like yeah.

C

If you are doing data mining or like you, are doing something and just like want to dump everything that is on the type the rests are there or parity or completeness I mean.

B

I will say, though, I think it's convenient to have an attribute that allows you to keep almost everything if you need it to, because that probably helps in debugging quite a bit. If you can just say you know what let me just annotate, this particular parameter here and then see what happens and then, if that works, maybe then you go down the path of finding more specific notations.

A

Also, the other consideration is that, like having more specific connotation, the only advantage is that you get smaller app right, it's not about correctness anymore, and so the question then, is like: how often is it that if I pick one specific method out of just 20 the charm, to type how much of a size, when will that cut me right, I mean.

B

It's the problem of graphs right I mean all you need is one edge to potentially route a bunch of other stuff right, it's hard to say in general, I guess.

A

A

A

My point of view on this is this is about correctness. Size comes second, and so, if we get something which is reasonable size, but it's correct, that's the win, and then we can start reasoning about okay. Can we make it smaller? Maybe there are better ways to do that. Yeah.

B

I mean there's only something we learned earlier in the, but the native landed having Epps dead.

D

B

D

A quick question on this on another question: uh if, if a type or a method does stick around, the linker doesn't shake it out, do all of the attributes on that API come along as well, so I could use reflection to access that data and.

A

That's a very complicated question, but the default mode. Yes, it will keep all the attributes, but there is a discussion now that, like especially with nullable keeping, those attributes has none significant size cost and it's probably never used to run time. So you know those kind of attributes which are like we don't really need to keep them around. So there's a discussion.

A

Maybe he remote to get rid of those and then there's a very aggressive linker mode, which is opt in which you can try to remove attributes, but that's very problematic right, but its are these difficult. It retrieves more than the truth. No.

D

That's that make sense the context behind that was, if I'm using reflection to get a method info back, can I do more than just invoke. It can I otherwise inspect it. It sounds like the answer is by default. Yes, even with us. Yes,.

A

Yes, there's the expectation also similar for properties. If you mark your property, we will all. If you access property through reflection, we will bring call the accessors, even though linker itself for like statically reference things will differentiate between getters and setters. But reflection will always prove everything because we don't know, what's going to be used, yeah I, look.

D

Forward to what happens when the linker prunes away the object, finalizer.

B

I mean the hiv-1 is a good one, because we just had the same discussion about the version. Actually do you want to put it in the iOS and Android SDKs and they are literally on every single API, so they will be very, very noisy and size. Wise, probably not great, so.

A

There is a discussion going on that. One of the proposals is that we would have a list of the known ones which we should trim, because you know we don't expect them to be used at runtime and they are used a lot if.

B

We can put mean that's actually a very reasonable thing, I mean. Ideally, we can also mark the attributes themselves with an attribute, basically.

E

Yes, and because.

B

Probably it's a function of the attribute right, let's form another function of the use side.

A

B

B

Any other concerns of the API is proposed here.

B

A

A

Oopsey follow.

B

Too many minnows.

B

All right, then, I will copy paste my notes down there and then.

E

The enum is going to be an INT rate, so we have 32 of these to add.

A

D

B

D

A

What would you add.

B

More than the ones you have here already very.

A

Sexually possibility that we would add more, but interfaces is another one and button recursion, something like recursive properties for first sterilizers, it's being discussed right now. We don't have an agreement and, along.

D

Those lines to you does it make sense to have an all, which is just basically the negative one value for this enum.

A

Oh yeah, maybe.

A

As I said like we're, starting with using this, so you know as we use it in the framework or purple run through cases which will make it easier to reason about I'd.

F

Be careful with all if they're unused bits, because all will then mean different things across different versions.

B

F

B

It now it's basically all ones right.

F

Right, but if you built something in five with all and then build it again in six with all, but we defined two new bits. It has a all means everything that we still knew about, but it will behave differently now.

G

The question would be is, if you said, if you supposedly set everything that's on here today, is there anything the linker would be able to trim out today that if you had it something else in the future, who would no longer mean the same thing and I don't know the answer for them answers no, because if that wasn't sure we would, we would already see more things here. I.

A

Think the answer is no, but it would have to double check it hasn't since there.

D

Is why I would not add the all, but even then we're not talking behavioral differences, all right like, ideally, ideally, if I said all I shouldn't see any runtime behavioral difference between five and six, even if potentially the size on disk is changed.

A

Yeah, hopefully a B, and we could also do it such that. If it's all, then we will check for it not bitwise, but for the value and, like literally, keep the whole thing. Regardless of what the period such as yourself.

H

A

Would always mean all regardless of version.

F

That's reasonable.

B

Would not make any sense, probably not right image case. You could probably use zero as a placeholder. Oh.

D

You wouldn't define this attribute anyway, if you passed a nun yeah.

F

It's business, if you don't put it there yeah, we should I. Guess that's a good point. We should add the word nun with a bit set, because we should just we always name the zero value and four bit fields. It's always called nun. You.

D

Know, I I guess a scenario for that would be if you want to compare the value against nun and then and then take some action, but you would never declare this attribute and then passing zero I I would assume. That would be a meaningless thing to do. Yes,.

A

It's meaningless right.

F

But it's if you to string something that was cast to this little print zero. Instead of none and curly up yeah yeah.

E

So I had none, don't add all that the decision.

F

Adding all is reasonable if all just says this type is preserved and the linkers not going to inspect it further because then, no matter what change has happened in the future, it will still have that behavior. My concern is just if the behavior becomes measurably different in the future than now there's a compatibility question and for we like compatibility, so we we spend a lot of time debating what it means so yeah.

G

D

Then that's a good point, but I would assume that a behavioral change there would actually be a bug that we would address instead of an intentional change.

D

At least that's my assumption, because I don't I, don't see how on earth all could mean anything other than don't shake anything whatsoever off of this type. The.

E

Recursion is kind of a thing right: okay, if we added that in b6, I mean this type plus any Plus any type, it references right-click, a graph.

D

Well, presumably, yes, because, if type, if a references be and I said, keep a around presumably B should be around as well write.

E

A

Recursive properties idea is that it would recursively keep properties on the reference types as well. I, say.

D

G

Meaning that the same settings that you've selected in this attribute would be applied to anything that intern referenced.

A

E

You being like a serializer case where yeah.

A

E

A

No fool pretty.

E

A

We could Auto that as a separate parameter to the attribute right, it doesn't.

E

A

A bit so the read out the all wouldn't be broken by then that's.

E

True good point.

G

But it feels like that would be cleaner because that's not really a member kind, true I sure.

B

Would read that yeah.

B

E

Can this be multiple? Can the attribute be applied multiple times on one.

A

E

A

Shouldn't should be on time on you.

B

C

E

Can't remember the default is here: why.

G

Why why is that? The case like couldn't I have a drive type that wanted to keep additional stuff around.

A

So this doesn't apply to the types. This only applies places very still, values so right and.

G

A

Is a separate rule about like overtures and overrides, where we'll try to force people to keep the whole tree the same? Because if it's not, then the linker has real hard problem. Reasoning about things so.

B

What does it mean for derived then you're, basically saying when you apply it on the virtual member, it will implicitly apply it to every derive type and they shouldn't be able to really clear it.

A

I think the linker current plan is the Integra would warn that you have to annotate the direct ones as well with the same very okay.

B

So that means the attribute would be marked as I'm, not the I'm not inherited and I'm, not gonna, so I cannot be inherited and it cannot be applied more than once.

A

Yes, I think that's true, yeah.

G

Sorry, I again, I missed the beginning. Side missed the context, but what what does this actually end up? Signaling to the linker.

A

So, on the consumption side, when you read a value which is annotated like this, it makes a guarantee to the linker that hey this thing has all methods, and so, if you call dot get method, it will work and it won't warn if it's not there. The linker would issue warning saying this: dot get method is dangers and we can't guarantee that it's going to survive the trimming, and so.

G

It's a concrete example: can.

E

You pull the slides up I'm over here, miss the side, steep yeah.

G

Sorry I had a question: I just want to make sure it's not stupid.

A

E

A

E

A

A

A

So the last line there that's what, where the potential problem exists, because the linker doesn't necessarily know what the type is, but the other type is right.

G

This is only applicable to fields and properties of type type. Yes,.

A

And string, and then it is seems it is fully qualified type name and you use it with like target type I.

E

See I'll carry over.

G

Can you go back to the together.

D

Just to clarify like we can't within the run time say this attribute is applicable only to fields of type type or string. That would have to be some analyzer or something that was making that claim. Yes,.

A

The delink I will ignore it everywhere else. Right now,.

A

Good also make it famous that's.

A

B

Sorry I was muted, I was saying you should probably warn because probably clearly somebody up with it and they apply to something else right. They I thought it would mean something that it doesn't. Okay,.

A

We can do this yeah.

D

My point was so that, if you did want that warning failure, whatever that would have to be some from some group external to API- were the official.

E

Are we planning on analyzers for this.

E

That's not the linker like a Rozlyn analyzer.

A

Yeah one day, hopefully I.

B

Mean in the beginning, you talked about warnings. What was those warnings be? Wouldn't they be Rose analyzes? How.

A

They would come from the linker suit, like whenever willing to link her to the ranch I, see.

G

Sense of being a question of how soon do you get the warning that do you want it as you're ready in a code, or do you want it only when you run the tool well,.

E

When you're a third party right, you might never run the tool you ship, you're, your library with bad annotations, and then it's your users. That would get the warning sure.

G

At the same time, though, there are a lot more things, presumably that those annotations could be a lot more reasons. Those annotations could be valid and, if they're not being tested, I, don't know that analyzers could, unless the analyzers police assume the functionality of the linker I'm, not sure you could get to 100% coverage. That's.

A

Why it's hard to write analyzer, because the currently the way the linker work city seems global knowledge and analyzers are by definition local. So there might be ways to do it, but it's not necessarily easy. I mean I, see because.

G

I agree: Eric idolizes to be valuable for, like the library author, but at the same time I think the library out there still gonna need to test. Oh yeah.

E

For sure, for sure.

B

Yeah would just be to make it slightly early. Alright I mean you said: violations like you put on something that isn't system.string or string makes sense, because you can actually make the local decision, but everything else here you have to test it for wheels.

E

If your cognate isn't enough to put these attributes or on your on your class, probably you're gonna test.

A

It as well or you should test it as well. I mean the testing is here, is actually simply it's literally running the linker on it. You don't have to run code. That's kind of the whole premise of this feature that we will tell you city cool it. You don't have to run the code well.

B

Yeah, except that you eat the only way to find out that you have missing annotations is by actually money development.

A

Well, not really because the linker will like, if you run it on a library which uses reflection and no annotations. It will probably issue many warnings, because any reflection call will be mark this wrong. Oh I,.

B

B

How good is your detection for said methods, but actually exhaust for fields is that hundred percent bulletproof were there his we yesterday.

A

Started yes, 100% bulletproof!

A

Well, analyst P, we have a bracelet. The goal is that, yes, this is hundred percent.

B

All right, so then it closed this one here, so he approved it. My notes are at the bottom here: there's anybody cares or the bullet points we talked about.

B

This is the next one.

C

Yes, my business one might be more controversial. We can look at the suppression instead, since the link into the chat.

B

Let me dig you talent, 3,.

D

B

Eventually, I will be able to copy this link.

G

Did we already discussed the namespaces.

B

Being used here, we did not I kind of looked at it in all. That seems reasonable.

G

I'm just wondering how we're thinking about things like these verses, we put all the nullable annotations and system Diagnostics code analysis.

G

I, don't have a strong opinion but I'm wondering you're, not no.

B

You're, probably right compiler service is meant for things that the user doesn't usually do themselves. This one seems more alignment with inaudible attributes that we want people to actually manually specify, so they should probably be the other namespace Jeremy. What do you think.

F

I agree with that assessment.

F

But it was nullable not with compiler services.

D

If there's going to be a large number of these attributes coming through, does it make sense to carve out a sub linker namespace for it, or is it not worthwhile to do that.

A

One of the main feedback in previous discussions was that this shouldn't be linked or specific, or the naming shouldn't like imply link in most cases at least oppression. One is special because it's like a specific tool, but the ones which are describing the code should be about the code and not about the tooling.

A

A

Me, how do you want to talk about this? One, oh yeah,.

C

Sure so the naming for this well yeah. This is the name that we came up with, but it may be the best name.

C

The purpose of the attribute is very similar to existing, suppress message attribute, so we were thinking that maybe can you suppress message attribute, because it's very similar to when you are getting a diagnostic, for example, tomorrow, so an analyzer, and you know that the diagnostic is not applicable and in the linker case, it's basically, you have reflection, but linker cannot reason about, but you are 100% sure that it's covered by something else somewhere and kind of the issue of the linker things could be at runtime actually will never happen.

C

So kind of this provides away how to suppress it and I, basically just took as an inspiration the existing suppress message attribute and I removed. I think two things from it, and this is the result, and the purpose is really to suppress message potentially from any tool that, after linker kind of or after the seizure compilation, which is why maybe suppress linker warning, is not great for name because we could potentially make it more general purpose.

C

But the problem with suppress message attribute is that the article is conditional and it's not usually generated into the il. So it's not useful for tools that ran after an across one is done. Is.

G

That early cherokees go ahead. Is there another compilation, constant that we would expect? We said we could always update, suppress warning, Express message rather with an additional conditional, so.

C

The thing is that this, the linker will normally run on kind of kind of the final release built off of your app and I. Don't know if we want to keep the code analysis things or all of them like maybe in Vinnitsa subset, but not all.

A

For example, these attributes, if they are in the framework, would have to ship with the final release bits of the framer.

G

Sorry, I didn't quite follow what I was suggesting and maybe it doesn't make sense, but right now suppress message as a conditional code analysis on it. If we added another conditional foo on it, then it would remain in a compiled binary that had either foo or code analysis set. Then.

E

We'd have to put fool for everybody, who's, compiling libraries and us, and everything.

A

Yes, yeah and like there are probably already places in the framework we would like to use it and thus means we would have to ship framework with the food defined. Yes,.

E

Can we give some examples, unlike when the linker wouldn't when the linker couldn't figure it out, but we are 100% sure where it's safe, maybe just one example. Maybe two.

A

E

A

An example in the slide section yeah.

C

But the example from the slides was when you take a system type and put it into a list or you put it into a dictionary or it wasn't a cold example. It was just kind of written example, so not so useful in the slides.

E

C

E

Example was when we were comparing two trucks and we're looping over all the fields, and if the field is trimmed out, you might as well not have to to compare it, because it's not there. So it's safe, it's safe to get all the fields on a struct, compare it with another one right. That was another case where we'd want to use this.

A

Yeah, that's the internal usage like there are actually many places in like coral lip specifically where we do things which are always safe, but from this analysis point of view are unsafe, but I don't want to like that's noise for this discussion right. It's internal implementation, details. If reflection for normal users, the case would be just the one which Michelle described for example, or anything which like when you cast it through non type variable so like if you store something in an array of object and the linker will lose track of it.

A

Try arrays are a good example in general collections specifically, but arrays are especially like bad, because there's very like the linker can do very little to trace it through the array.

C

Just today, I was the CSV naughty code, generator for the new way of doing WinRT intro and that one uses a reflection, and it has some kind of dictionary of the protections and that's exactly I use case for for this. This thing, because they play something a dictionary and when they are placing it into the dictionary, it can have the right amount ation and you kind of keep the default constructor, because this needs default constructor as well, and once we are take it out of the dictionary, it doesn't have the annotation anymore.

C

But we know that because the dictionary is controlled by us that everything will have the default constructor. We can just the linker that, like hey, yeah, I'm, doing activated creepy instance. But this thing it was an annotated, but it's fine because I know it's fine.

D

I have a related question for you, since you've been doing a lot of the analyzers work lately. How do we feel about having suppressed message versus pragma warning, disabled.

D

A

Just want to add that program learning disabled is not viable because it doesn't survive, compiler and so blinker won't see it so.

D

The idea is this: is a library I put this on my library and then the consumer needs to be able to see this attribute so.

A

The linker works on all the I/o in the end. Oh yes,.

D

It doesn't see partners but.

G

If I were to do something like this, maybe based on the description earlier and on the screen, I mean it really seems like the sole difference between this and the existing one. Is that the existing one has a conditional attribute on it rather than this being linked or specific? It's just do you, or do you not want it to go away? Based on what the code analysis is said, if that's true from a naming perspective, it seems like that's the key difference.

G

You know unconditional, suppress message or some other better name that I just came up with yeah.

F

Persistence, the other name that was floating in my head.

A

I agreed to name lease finished. It is just the working prototype if.

G

We were to do that. I, don't know if there's any benefit, but we can consider like inserting it somehow into the the hierarchy here. So you had like you know. If we were designing this from scratch, we might have, for example, had attribute and then driving from that the unconditional suppress one and then deriving from that, like the suppressed one that has a conditional flag on it or something like that. I don't know if we could somehow sim it in here in a non-breaking way, but look at that too.

F

I think we get added it as a intermediate base class without breaking anything. You.

G

Have to move everything down to it.

H

A

It could look a identical to do one. We already have that's, not a problem.

G

Right now, I'm just the game, you know: what's the cleanest yeah.

A

I understand it.

B

Just means you have to name the bass, funky.

F

If I named it conditional or something else to suppress message, we might need to put new on all of the delegating members on existing suppress message so, like its category, would defer to the base category. Maybe.

G

F

G

Just a separate one.

B

G

B

Need to do this because my alerts, it's always safe, to call to the direct one. You don't have to really clear them. You can just literally move them down. We've done this in the past.

F

Fair enough, the.

B

Ceo was like all I'm saying is that you would have to find a new type. That is the base. Why didn't that? One probably has to have like suppressed message attribute base or something right, because the generic name is already taken.

G

I'm kind of going I'm just thinking about it, the fact that the additional one would derive from the unconditional one is a little strange because then, if you just did a type check, is this unconditional? Yes, oh.

B

You suggesting the other way around well.

G

Yeah neither way makes sense, because I think the conditional would end up being.

F

Inherited right well, if we took so, if we did it the other way, we've had, we took suppress message and left it as is, but presumably it's sealed and we need to unseal it. And then we said an unconditional, suppress message extends conditional. The problem we would have with that is. If we were still servicing FX cop, we would need to teach FX cop that there's another derive type it should care about by then the the is test makes sense. An unconditional suppress message attribute is a suppress message, attribute right and so I.

A

Think you're correct it, like none of the tools actually do type checks. It is in this test. They typically check for names because they don't have to type load. It right.

B

It only helps the documentation like generally speaking, attributes like unless you really want to instantiate the attribute like polymorphism and doesn't tend to help you, because you generally tend to look at the the metadata itself, in which case you need to look at the specific names or types right, but it does help the docs I mean if we did this finale' ball to just be able to group them all in some sensible fashion right, so I think it would make sense and.

F

Then it would be up to tools to decide that they want to check for suppress message or unconditional, suppress message and I. Don't I, don't know how many tools we have that are actually using suppress message now, because the like Rozlyn analyzers are looking at the source code they're, not looking at the output il. It was only like that was only invented because FX cop and the linker are running on post compiled so.

B

I mean it just means that whatever the suppression mechanism exists in Rosen, for example, they would just have to special kids as other attribute as well totally.

G

Left-Field and probably the answer's no, but would it be feasible to just remove the conditional attribute from suppress message and say if you actually want this stripped out, use the linker.

B

You might be under estimating how much space that wastes, because there's a lot of strings right with justifications and other things, and my gut feel, is that people will be probably upset if you ship their justifications to their customers.

B

F

Especially people coming from framework where they were using FX cop and they just have a process they've been using for years and then they switch to core and find out. Oh, we don't the attribute, isn't conditional anymore. It's now always included in your release. Output.

B

So I mean I, don't think. There's many static analysis tools that have to look at the attributes, so I think adding a new one and just teaching everybody about. It seems very global to me.

B

Especially because we can just start with saying you're the only part of the owners, it is the tinkerer and everybody else just hasn't done it yet. Yeah.

F

I mean the question just comes back to do we do we make this extend the current one, because that makes us feel good, or do we just make it a sibling that looks exactly like it, because that's how all the tools are going to treat it.

F

And I don't have a super strong opinion. I mean one.

A

Can we actually extend the existing one, because it's conditional I, don't know how the rules work there like? If you know like if the base class is conditional, does it mean that the derived class is also conditional.

B

I guess it depends on conditional itself right.

F

I think it's only on the per target, so it would just be that the constructor is conditional, but it can't remove it without I have no I think it would only apply to the attribute usage and not the attribute constructor chaining, so I see yeah. So as long as it's a new type, it shouldn't unless itself is marked inherit it, in which case we'd have a problem, but I don't think it is.

B

B

It's not inherited No.

A

So can we agree on a name at least.

B

I mean paging in what we did for nullable. Our conclusion was because Corvallis is such a small namespace. We did not include the base type I'm, actually fine, with making. This just appear to suppress message but I'd, like Stevens suggestion of saying you know, let's not put in linker in here, just just model. The actual distinction that it has, which is is unconditional, so unconditional, suppress message attribute, seems fine to me.

F

F

A

F

Name was persisted: does anyone prefer persisted I'm only asking devil's advocate I. Don't actually have an opinion, I think unconditional, probably reads better all right unconditional. It is.

D

Ever persisted I'm mulling that over it it sounds like the opposite of ephemeral and I'm, just having trouble just to find it myself what that means.

F

Means I say that word persisted a lot in my day-to-day job.

A

And just to make it clear eventually, we think we should teach Rosalyn to recognize the new one as well right.

B

F

And Steve did a test instead of a code inspection and says that conditional is inherited through attribute extension. So, let's just make it a sibling. Yeah.

E

Attribute usage is inherited as defaults to true it doesn't have it on its dock. So it's deposited.

E

If we make this a separate type, do we want to have an interface, so people can code against both.

A

Again, nobody goes votes against, attribute the tools like look at it as a strikethrough sort of a reflection. Let's connect very rarely. You actually see an instance of distinct anywhere and use.

B

All the tools to learn like.

A

The tools to string matches right, they don't actually load the type.

E

E

When you final trim, the application, is this gonna be another one of those attributes that we would put on the list to strip out? Because you don't need it anymore. For.

A

Applications I think that's a good candidate, yes for libraries, there's the answers of this line: oh yeah irrigations. Yes, we should prepare it just like the dynamic Alexis one to the previous one same zip story.

E

Right cuz nobody's going to use it at runtime.

E

B

E

Don't forget to change the namespace emo.

B

B

C

Want to unpack the two properties that I removed compared to the original suppress message, activate yeah.

B

I would move I would literally have it exactly as suppress message attribute.

D

H

Just maybe one more thought on the name wouldn't be better to call its presage unconditionally kind of make the discoverability better.

B

I mean we used to do that in api's.

B

My key level has brought significantly because rosin effectively in intellisense. Does you know prefix and suffix search? So if you just press, suppress linker warning, so if you just say, suppress message, DEET Ellison's will show you both suppress, meshes and unconditional, surprise message and it's highlighted so that you see where the common Burma is so people will find both of them.

B

I can mean prefixes might be better for sorting, but as far as intelligence goes, it doesn't matter that much drama pains if somebody feel strongly that it should be a suffix I can't rule it off. Of that.

D

I, don't care about prefix versus suffix, but regardless we would use unconditional. Instead of unconditionally. We tend to use adjectives rather than adverbs in our API names.

B

As it something's, it will be we're doing.

B

Like adjectives at the end, sound weird.

D

If you've been looking at the intrinsic stuff coming along, oh oh.

B

Yeah but Dallas I'm not going into the whole of great API yeah.

E

But there's nothing we can do about. Somebody knows all I want to suppress this. They start typing, suppress and then they're like suppress message. That sounds like there. A one two hit that one and then bills, and they still get the warning right or link- can still get the warning like there's kind of nothing we can do because suppress message is already taken, the good name right. Then they just then they just search linker, suppress message, not working. It's like, oh, you should use unconditional, suppress message.

E

Can I have to live with that rain yeah.

B

That one I mean yes, but that's true. What godless right many people use the wrong I do what they used to my interview, the linker.

D

Messed it like the the error produced by the linker could have the sample of what to apply right. True.

E

And every time but true.

E

D

I have a feeling, even if we, even if we had suppressed, link or warning attribute, you would run into the same problem, because people would just have suppressed message, because that's just kind of muscle memory for everyone.

E

Yeah you're only gonna hit this once.

D

And, and even even though we say that you're right it is, it is important to optimize for the very first time I hit it. I need to very quickly unblock myself, but yeah.

E

Maybe it is a good idea for the linker to say if you feel bit if you're sure you can add this attribute.

D

Or if there's like an fw link to somewhere, it could be like the first paragraph in the fw link or something like that. We've done that for a few other things too,.

A

In general, I think we will need the links, because the explanation is typically pretty complicated and it doesn't fit into a single message. So we should have room in the docs to do this, and the warning should probably have a link.

H

B

I mean general, like also for attributes you can localize in and depending on how you surfaced. Yes,.

A

That's also true, no I mean this is also like. You know, when the linker creates the generic message that it saw this attribute right. It would probably have a link it already.

B

All right any other concerns, or is that.

B

And we can once OH.

B

E

We do preserve dependency first.

B

People who should.

B

Bang what's easier when they both look but I think the argument was that this one was more controversial. I think.

E

Preserve dependency is more understandable, like there's not as much explanation needed. Yeah.

D

I think we already use it in our framework to some extent yep yeah.

A

It's just internal so the years to make it public and come up with a better name.

D

I really wish we had in foof, because that would make stuff like this a little bit nicer. In my opinion, Oh fishery, like I, feel I feel kind of bad that we're that we're introducing new api's like this, that have a wart, because we don't have info of as a proper token.

C

You wouldn't be able to use info for our custom attribute because there is no metadata encoding.

C

Got my only a couple types can be encoded in custom attribute blobs. You.

D

Know I thought metadata tokens could as well nevermind also.

G

Some of these are actually preserving things that you turn and aren't, even in your compilation, assembly.

B

I mean you could imagine like something like Namath right, where it just gives you the string. This is our feature, but you.

H

In general, if, if the compiler can see, then you need discipline.

B

Well, that might also be true myth in.

A

Fact you shouldn't use the attributed to comparators. You can see it see, that's actually better. Behavior than attributes.

E

But the only way you know is, if you test it right.

A

E

A

Oh, like it's either in your reference closure or not right.

A

I, don't see it, I mean.

E

Like if I, if I have some some code, that's called using reflection to call some-some method and then I run the linker on it. I need to like go look. Did that method still stay here or not later, or actually run my app and see if it still works.

A

Yeah, but when you're compiling the code you either have the target type in your reference closure. If it's there, then you should take a stronger, for instance,.

A

E

A

Run time is lazy right, so, like none of like none of the dynamic loading will get you much in terms of like laser loading or anything. The strong reference is pretty much almost always better.

E

I got it: I thought you meant either use preserve dependency attribute, but don't use the reserve dependency attribute if the linker can figure it out upset itself.

A

Yeah, that's also true that most cases linker will figure it out, but.

B

A

It's if it's like a simple, you know: I'd get type. So what.

B

Is the encoding that you use for signatures.

B

I guess who these types are fully qualified right and it's kind of.

E

B

In c-sharp syntax, why I mean that's the problem that we have, that it's not it's not straightforward and, like you know, for example, you do have generics. Do you do angle brackets or do you have the reflection encoding that involves some crazy gymnastics.

A

So for one I, don't think generics work well today, that's something we should probably fix and type names are simple. Just like fully qualified type name, including Assemblies and members member signature. I, don't remember, maybe Marik would know what is exactly the syntax like the simple stuff looks normal, but like the more complicated things I, don't remember.

B

And that's the problem that the you know whenever you have things like this is like you run it, and then it doesn't match anything and then just nothing happens. At least you should give people an error when they or a.

A

B

When they refer to things that you can't find I'm, pretty sure people will make mistakes where they, you know, type just the signature wrong. They misplace to call morale. They edit a space somewhere or whatever the case might be right.

A

Yeah I think it already wants. If it cannot find a target, you will get a message.

A

But I'll make a note TT.

E

How does the first overload work here just say: I want to preserve to string.

E

On what type what's assembly MacDonald? Don't.

A

You always need.

E

To grab the third attribute or the third overload, or is it assumed to be the type in the current that you're on? Yes,.

H

Soon, as it's going to die, okay.

E

And then same for assembly, it would be this type. I can't want to be this type in the current assembly. Okay,.

B

A

Think I think what is important like Eric should probably talk about this sooner but like the use case, for this is not just a simple reflection stuff that it's cases where the dependency comes from non-managed code.

H

So basically, the second common scenario is, for example, you do runtime call right in your class in your method and then this certain time call all calls back into your signal ass right. So you want to keep dependency inside your class and you don't have a strong link, just use that I.

E

B

Danny when.

E

B

We go ahead. You.

E

It says you can only put it on methods, constructors and fields.

E

Again, in that case, you'd put it on the first method that calls into the runtime.

H

Yeah you call it on the method which has the dependency right saw that so that's up to you. You can put it as many methods. You can you you need. So basically you can have reserved dependency into same member from multiple methods that again make sense. If you code, I, have called handles the third thing.

A

Was a scenario for having a field.

F

Presumably, the field is declared with an initializer of get member type of, or this get type comma etc like so it has extra.

A

Lizer expression that.

F

Uses reflection so.

A

It's effectively putting it under study, constructor, yeah, yeah.

F

Interesting, arguably, we could say that that's not important and just make that a method and paint it on the method, but I don't see a problem painting it on the field. Okay,.

B

So is any reason why the.

B

But these are all read right, because normally the only property you want to have read right at the ones that we consider optional for an attribute. I would normally expect members, signature, type nerd assembly name to be get only because you only pass them through the constructor and then only condition is something. You said, optionally.

D

I agree: member signatures, high payment assembly name, so member signature should be non nullable type name and assembly name should be knowable and all three of them. Should you get a link, but.

B

Does not mean like even the first like there is just preserves with the constructor. Does what does the first constructor mean when you pass it no I think.

D

That should be nominal only the type name and assembly name and condition should be knowable.

G

I think they were reckon I'm wrong, but I thought they were knowable so that you could basically say keep everything and in that type, for that assembly. I.

A

Think you say star for it. It doesn't allow some amount of like white cards which.

G

Does raise another question, which is this we add the API of this attribute isn't limited to what we see on the screen. It's also, what is the format that's possible for each of these things right.

F

Also, the namespace is wrong. Yeah.

G

A

Name of the type is.

G

Not ideal yeah.

D

Yeah, because if you look at how we use this type internally, today.if method a relies on method B, then you would put this attribute on method, B and passing the member signature of method a. But it sounds like from the discussion that we just had. It's actually reversed. No.

A

It's a split on a.

E

A

For example, you will find this in quarterly in places where it reaches out to other assemblies in the forever. Oh yeah.

D

But I'm saying like right right now, if a calls be indirectly, this attribute right now is placed on oh no you're right here, right, okay, I'm, ignore everything I'm saying.

A

You Stephen, you had some like good naming suggestions. Skinny, maybe burden bring them up.

G

They were my concern was primarily that the preserve part in particular is talking about an action that we expect a particular tool to take in response to this when, in reality, all this is doing is just saying, I have a dependency on something, and you have something that you're unable to determine otherwise do with that information. What you will and something like the linker would then choose to say: okay.

G

Well, if I'm going to keep you I'm going to keep the thing you depend on as well, but other analysis tools would just use that dependency information for other purposes, so that preserve felt wrong to me.

E

Would requires, or with that word at least, be better dependency required or requires dependency or depends.

G

On or has dependency or implicit dependency, or you know something along those lines.

F

Reflection dependency, non-static dependency, dynamic.

E

Dependency, dynamically member to access kind of thing, dynamic dependency. That sounds like English, good job Eric. The.

D

Thing is it's not dynamic, like it's known at compile time clearly.

F

A

Itself is using a dynamically right.

A

G

Referred to as being dynamic is that the mechanism, or is it the knowledge of? What's the target.

F

Because if you, for example, semi statically used the keyword, dynamic I have no idea if that works through peyote, but the runtime can't look at it and know what type you used, but you can be like I'm totally calling that members to string or that types to string like I can see it in the code right now. So you have a you: have a static, dynamic reference.

F

F

So I, like dynamic dependency,.

B

I mean it depends on what you want the thing to communicate, right, I think the idea is that preserve means that don't strip it outright well,.

G

That's how the linker would interpret it. That's my point.

H

Just maybe one point I would raise this if you make it to university risk that some people will use it in their frame works for something else. A technical obviously will keep more than it's necessary because they were just abused a lot. You yeah.

B

That's kind of my point: I think we just had this discussion recently. It's even right on the pure attribute right, we're pure, were kind of had a very broad semantics and then different things interpreters differently, and then we ended up of saying no really want an attribute. That specifically says: don't ignore return type right, so it seems, like you probably want attributes that a bit more specific on what the mechanical interpretation of this is, and if you want more, you have to apply more attributes.

G

I see those as being different, the the pure thing was is actually the problem. Is it actually is tied to contracts? That was my man section to it. So, the corollary, it would be this being tied to the linker.

D

You you, so are you implying that you want the word linker somewhere in the API named for clarity me.

G

No I'm suggesting the opposite that and the this thing the only purpose of this API is to say: I have a dependency on something else like I depend on this other thing. The linker then chooses to assume from that. Okay. Well, then, I better, not remove that other thing. If I need it, if I need you, but you know, I else, PI could use that to navigate to the dependency or to show it in your. You know, use references, that's not has nothing to do with preservation.

F

Yeah I think it's describing that you have it that this member has a dynamic dependency on something else and, yes, you can painted it to hide up too high of a level and something like I else buy it. It makes no sense for it to jump from there, but you you painted it there and you're, describing a relationship between this and something else. Not Deere linker, don't delete this other thing and the linker interprets that relationship as good I'll spy or any code or any other sort of tree view.

F

Type thing of code flow I mean.

E

Even find all references in BS could respect this right. Sure no references of this thing finds dependency attributes other places. It's.

F

Because it's describing the relationship and so I think it's good to leave it general and not tie it to the linker and if somebody abuses it then fine, they don't link fine or they don't link cleanly.

F

That's the same as if they type everything as object.

F

Or whatever other things you can do to make the linker angry yeah.

B

I guess, as long as we think that this is a very specific and clearly defined thing that the same codes I, think I'm fine with man I'm just worrying when you have multiple interpretations based on attribute. This is same thing we had with things like XML Sheila is a rare. Obsolete, no means you know, hide it from civilization. When you really want two different attributes doing to express these things independently right, it's not only concern that we, if you make it to general, then you bucket decisions together.

B

Did that you'll find out later that you want to make independent decisions for those.

B

Dependency, if it's still very well-defined, you just say I call this other thing at runtime, somehow think that's fine! It seems very specific.

G

G

I, don't know the right forum for it, but there probably does need to be discussion about the syntax. That's used for all these parameters. Yeah.

B

Added as a note, what's the syntax was a signature. It seems vodka is also supported, not sure that's discoverable. The link should at least think I should at least one when the string can't be managed. So does it also mean we concluded that members in here should not be nullable right? That's the other thing we said.

F

Because it's a required property yeah.

B

A

F

A

I just checked it to see passing a linker will crash.

F

I guess saying the all bike to put a constant string hanging off of this of all members. Being this, the asterisk or whatever it is. That would also make sense and I guess it. It could still make sense for tools like I guess really. That would only make sense to the linker, but other things could still do something with it like not show a number is being uncalled because like well, something said it has a dependency on everything. So.

A

B

That's the pulling of the this thing, for example right like, if you say do you have Wild Kratts support, then I, don't know how it's by a little work right.

F

So is there really a need to do the wild card? There's.

G

We definitely just case farthole. Let me pull one up: okay,.

F

Angry typing yeah and I mean again from a technical perspective. Does wild carding mean public members or all members.

A

It means everything keep the whole thing untouched, as indenter type.

D

You does it make sense to have a separate attribute just for keep this type around, where you could actually pass a type out to that, or is the idea that you don't necessarily have a type of that you can get a compile-time yeah.

F

Because didn't we talk about? Wasn't that the first thing we talked about a type of and uh and the flags of what you care about.

A

I think the point of this is like: if you can do type of tan, you don't need this attribute.

F

F

Except this would only keep one member around the other thing we talked about keeps categories of members around you mean.

A

The first attribute to be discussed: yeah, yes, but the use cases are different.

F

Yeah so I guess that is one question is on the two constructors here that take type name or where we have typed name an assembly name. Does it makes sense to have a another constructor that takes type of, and we could certainly make it populate the other two members, but that way you can still get a. You can have a strong reference to a type that you're just encoding a dynamic member reference to.

A

A

F

Yeah so then yeah, the only thing really is I.

F

Do agree that this is a very long list of things needed on make update delegate. But if we're only gonna have a handful of such cases, then maybe it's just worth the cost of splatting a momen like that. If we don't think that they all makes sense in the general case well,.

G

We just look at an hour remaining piling trim files like there are various places we use star, okay, I think I. Maybe we got rid of all of them.

C

How many of those we could replace it with the first attribute that we discussed was even like when I'm, even looking at? What is this that dynamic update, delegate or whatever? If we were to rewrite the code, so the linker can actually see the text in there. When we are not string formatting things, then you don't even need to annotate, because, like this, this linker could see through it.

C

There wasn't like update exactly devoid plus rx tab length if there was the proper string that we have up here in the preserve dependency anyway, one of you, you don't want a tribute that wanker can figure it out. I.

A

Think the world card question is America true, because this is used a lot in some Marine Park. Do you know whether you need to vault card.

G

I'm just looking in it like core libs I'll lean trim file and while we could so there're various places to be, is that one is we use it on a not to keep around anonymous types which have unknown names. So there's you know, will basically say it on this type star to keep around anything. That's been generated by the compiler.

G

That's for then source stuff. All the marshallers have stars, there's a star for everything in something to do with component model event. Pipe has a star. Next to it, we this one's just for convenience, but there's, like you, know, a bazillion, different method, builders for acing stuff. We need to keep the same two members on each. So we say same task method, builder, star grip,.

F

So I get but the the question. If the first attribute we discussed today, if it takes a string for the type name, and we just said we have a whatever the relationship it was describing against the type and we keep the whole like. That's that's the same as using this with a star. Is it not and.

A

No, these cases are different. Okay, you can.

E

A

Replace this one or direct letís say.

E

You had a private say: you had a private construe, your type with a fully-qualified type name, and then you put on dynamically access members and then whatever categories.

A

Yeah I would have that effect. I, don't know whether we would want to I mean.

E

The end of the day, what's the difference.

A

It's really hard to read, you know, reason about: why did.

F

You do that right, like look smart, it's because if we say that this doesn't get a shouldn't support, wildcards in members signature, then because we were making it general like we can. We can leave it I'm, just like we're I'm, just asking the design questions here of. Are we are we shipping something for a tool or are we shipping something that's generally useful? And if we think it's really close to generally useful, what are the tweaks? We can do that make it meet all the scenarios and I.

G

Got to understand your question: can you repeat it so.

E

I'm saying we would reap, we would use this attribute for if you wanted a specific member or like two specific members, but if you wanted, like all the properties or all the methods or in fact the whole type another way it could be achieved would be private private cons, string.

E

Name of the variable you want it to be is equals some fault, fully-qualified type name, and then you slap on dynamically access. Members attribute from the first discussion with all the members that you needed to preserve on it, and then the linker sees that on that field, and it says oh I see this is a fully-qualified type name. Let me go look at what members I should preserve on it, oh all of them.

E

So then we wouldn't need. We wouldn't need the wild card. Support in dynamic dependency attribute or preserve dependency, attribute, I thought.

D

Courier slides earlier that pattern was recognized by the linker anyway, even without the use of attributes.

A

D

A type of whatever dot get method, method, name yeah- that is recognized.

G

That's not what I'm saying no.

D

G

Const string, something I depend on equals, quote you know, food type, close quote and then add. On top of that, the dynamically method add dynamic, attribute all and the linker would see that and say: oh I see you have a Const field, nay, that is given the string value who type therefore I'm going to keep everything around from foo type.

G

A

Yep, so the answer is yes that would work. It's just that it's very kind of hidden wait.

G

What did the linker strip out that Const.

A

If it's not accessed anywhere else, it Riverwood.

D

A

D

Ever access to fire reflection anyway,.

F

Yeah well then, later stage compiles yeah.

D

Yeah but I mean uh cost is part of it's part of the assembly metadata, so people outside of your assembly might query the value, but people within your assembly will never ever do you reference the field that has a cost value in it.

A

Think, like the answer is you could make it work with some magic. Like you know, there are certain places where you need to reference the type and the way you do it is just you type of an assignment to do like discard right, and so you could do something along those lines here as well. The question is where it's better, to separate all cards on the attribute we're looking at or whether we would force people to use this.

A

Having methods instead.

G

Of the first parameter or in it you have, you have the constructor that takes the member signature, the type name, the assembly name. You can also have one that takes the type name, the assembly name and one of those big nines. You talked about earlier.

A

E

F

Yeah and then the question is, do you need wildcard support in the type name and please don't yeah I was gonna, say and hopefully no so when.

G

I also do like the suggestion I forget, who made it earlier of having a string member signature and type but existent type of the second parameter. Yep.

D

A

Just to clarify.

D

If the type is the type where this attribute has been applied, then you don't need to specify a right. It's just assumed prayer. Yes,.

F

Pretending that you can statically save this, that get type as I might pretend metals or I wish that all the time.

E

Type of current.

F

Yeah type of this magic.

A

F

Is the class you're defined.

D

F

D

F

We want the three existing constructors and then string member signature, comma type type and then another one with type comma, whatever Flags or.

G

Whatever Flags comma, either type or string.

F

G

I mean it's possible. The latter one is speculative, I mean we'd, have to go through and see like what the actual use case for that is. We know we had to use cases for the ones on the screen and and also where the the type is the type I would imagine. Actually, the bulk of our current usage would just use type as the second argument.

E

There's a lot places in these Iowa I'll link, trim xml's, where it just says type this full name I'm. Assuming that means keep that whole type. Yeah I mean in core Lib, it's at least 30 to 40% use.

F

Right, but was that accurate, or was that I'm tired of typing things.

G

Sigh which, which what are you looking at Eric, you say this 30 or 40 that are just type 30.

E

To 40% 40%.

G

E

System private correlate, I'll link, trim, genetics like almost all of them at the bottom yeah.

G

A

That would be mimicked.

G

By the night, star or dynamic members, all.

F

So that would be dynamic, dynamic dependency, whatever kinds of flags we called it dot, all comma type of whatever.

G

Assuming we had a place to put that attribute, yeah.

F

Yes, I mean we could say that we want to open it from method, constructor and field to also say class of, don't ask why, but this class depends on something but like somewhere. You have the method that cares and you.

G

F

F

But by loading this assembly I assert that this type is going to be used somewhere. I mean.

E

The case is in a few cases in Korolev is like the debugger needs this right, it's like! Well, what method are you gonna put that on inside core Lib? That says the debugger is going to need object, that cash code.

G

That's true: we've hit this in a variety of cases where we've put preserve dependency on on things that we hope are going to get hit on the path. The thing that's, actually you know going to be used and a lot of them have to do with debugger.

F

And that maybe a separate private mechanism, if we find that there's not a good place that we can put it right, it's but something well I could not. We don't want users to do yeah. Can you avoid loading void.

F

Like if this had a class target, you could slap it on like if you'd ever talked about, if Boyd ever gets loaded well, it turns out. It has to be so.

G

Your string bean system void yeah we're gonna, have a hundred attributes on system void, yeah.

F

Sounds great, no one ever looks at it. Yeah I mean so it's possible. We would do an assembly level attribute in the core Lib. That is super special to this tool because of the debugger but or yeah, but I. Don't.

B

Think that would leaves its specific to call him. I mean I, wouldn't know. High-Level assembly have similar issues.

F

I, don't think the debugger is going to be direct calling into anything else. In any I mean there's.

E

F

Guess there's a question of like: does the linker need to preserve or should the linker be preserving? You know the attribute that says: debugger display go call this other method and I. Think.

B

It is that's already covered, I. Think I, misunderstood you, member come by the burger, then buy the burger. You means basically, Deborah has a private handshake. Specifically, we've called it to reach into the runtime to get some state. It's not for making certain types debuggable right.

G

But that does apply more generally to anywhere where some external dependency wants to be able to use something like if, if I have some native code, that's going to call into my assembly, or you know or some other something that me I know my this thing is gonna be used by someone. Is there a way that I can attribute it to say, like don't, don't remove.

F

This I mean if we think it makes sense to widen this to a method, constructor field and assembly, so that there are places of like just this needs to be true and find all references will say: yeah you loaded system, private, core Lib, so this type can't go away. I, don't know why it needs it, but it that's the relationship. Then that's what I think Emily.

B

Why would you not have an attribute that you just put on the thing you want to keep always basically basically treat this as a rule? Never ever link is the way this assemblies in this thing is in yeah.

G

Just say preserve dependency, no or whatever we call it. Maybe it's not even this attribute, but like the thing with this apply to you should never be removed period. Yes, no dependencies just like this has to be kept.

B

Because that seems like what it is yeah cuz, then you also don't need a proxy thing right. You just put it on the thing it belongs. I don't have any encoding issues, you just put it on the thing and whether.

F

B

Or an overload or whatever it doesn't matter, but.

F

That one that would be specific to a linker right.

E

Would be a different attribute, it would be this right. This one is thing that I'm putting it on has a dependency somewhere else right.

G

There be something else that was specific to a linker that was do know this. This method remember whatever must always be emitted, don't try and avoid it right.

H

Before that, it's not using up too good is this XML, which was closed. All the cases in.

G

G

Be nice if there was a way of expressing it in clothing, right.

F

So there would be something like externally referenced or you know yeah or something like that. huh But.

E

Here: here's a case where, like we might just need to use it and we wouldn't have to open it up for other people right. We could maybe get away with not having something public there, but.

F

Or again, if it's just the the things of like dear linker, this type can't go away and it's specific to the linker. Maybe that means it just stays in the XML file and it's and it's a thing for the tool, but it would be. It would be nice if we had something standard applied on the things of like no matter who writes a linker in the future. Please don't delete this.type, because the debuggers you're you're gonna crash the debugger.

H

Just speaking of the debugger, we definitely need to have a mode where we remove the debugger support, so there will not be cases just to keep stuff all the time for debugger.

F

Fair enough, so that means maybe it is still just the XML file, and we figure this out in another couple years know.

E

It kinda isn't, though, well if you want to move if, if we're using the XML file to say always keep this thing in here, but we want to have a mode of the linker to say strip all the debugger stuff out right. Then we kind of need to mark certain things as like required by debugger kind of oh okay,.

F

I teach there and so yeah, so maybe that's a maybe that's debugger required is it's the attribute that we want in that case, but I think that on on this one, if we drop the wild-card support from it that we've we've probably beat this one into either to death or into the shape that we wanted I'm, not sure which I have one more question about it, though. Okay.

E

We talked about condition.

E

The last property on this thing that's.

B

A good point: yeah.

H

Oh yeah half an hour and I guess: yes, I.

F

Mean I assume that this is supposed to be that you want this to be like the conditional attribute but conditionally applying this attribute my wrong.

A

Sure the way it works currently is that's the debugger support. You can say debug there and it will be kept. Only one little increase asking to keep debugger support around and so.

E

A

E

A defined constant yeah.

A

F

Specific right now, so it's it's like the conditional attribute and it's the it is the attribute conditional attribute yes and a specific variant of it for this thing, yeah, so that that is exactly what I guessed from that, and so it seems fine to me.

E

But it's not like an expression of any sort right like greater than equals. No.

A

E

A

At least literally not right now, currently in the linker, it only supports a single value that is debuck yeah.

F

A

What did we call it on the conditional.

F

F

You we called it condition, string so conditions, fine condition.

B

Stream yeah I mean I, would say, condition is not great because it kind of implies like a predicate or something right. Probably conditional symbol would be better or some whatever all preprocessor similar. Whatever the thing is called in c-sharp, you that's what it maps to right.

A

No, that's not where it types to attraction. The.

B

Debug does not mean debug has said it means something that so.

A

Unwilling to do that as Merrick suggested, there's a mode Ferger linker where it tries to strip stuff, which is necessary only for debuggers and if you say debug, it means keep this only if you're not stripping for debuggers.

A

So, like you know, we support debugging, release code right, and so, if.

D

You actually run.

A

The linker on an app with like strip debugging and debugging it even debugging that version will be pretty bad, like you probably will lose all the visualizers, for example,.

H

Yeah I think that the motivation was basically to give flexibility to describe with further the dynamic dependency condition. So, for example, you can use this, follow it's a civilization in theory- and you say: ok, I need this dependency. Only when I'm running in I don't know civilization, dynamic mode or something like that.

E

Or like a user, could do it if they had two applications right like and I, have this dynamic dependency only an app one, so I'm gonna set that when I link app 1, but when I link app too I'm, not gonna, set it, and then it's.

F

Going on, but it is it's sort of like defined constants, it's just that, possibly it wouldn't be using the same value out of the cs. Proj. Yes,.

E

A

E

B

I mean it does raise. The question that you conditioned to me implies either it says, even if we do it after the conditional way, it's just a single string or meaning a single symbol, whatever that symbol means but like over time. If you need to support multiple things, will you ever have something like the bug: Kumar, profiler, comma, whatever? Why is there? This is always going to be a singular string.

F

I would think a comma or semicolon, or whatever syntax we want to support for a list would be reasonable of. If any of these is true, this is true.

B

Yeah, which case it probably should be like I, don't know conditions or something I mean the question we becomes. I day. Will you ever have something like you know, not the back or this, but not this and this or that because then becomes its own mini DSL.

E

Right you'd put multiple on if you wanted, or.

B

A

F

I guess I'll have multiple is allowed multiples. True, because you get it, you could have had multiple different dependencies anyway, so yeah. So that may be fair, so condition may be single dependency and there is no there's, no handing. If you need anding, then you you need to do complicated stuff yourself. Another.

E

Condition, that's both of them.

E

Okay, I think conditions.

F

It did exactly what I thought it meant just it's not using the same necessarily using the same value out of the cs. Proj. So that's that's more a tooling experience, but it semantically it matched with my expectations. So it passes that list miss litmus test.

E

Okay, I have no more questions.

F

Sorry Levi, we still didn't get to your thing.

D

That's fine I'll, just check it in and deal with the consequences.

B

B

All right, so let me just quickly piston also make sure that they're, accurate.

B

F

And we currently can't see your notes, no.

B

You can't I can barely see my own.

B

B

And representative utilization sucks everything is delayed.

B

B

F

And you missed all the other constructors, we said it should have wood.

B

All the other constructors.

F

Remember, name, comma type and binding flags that we had from the first attribute, comma type and the binding flags we had for the first attribute I'm a type name and the binding flags went first from comma type name, comma assembly name.

B

Okay, so let me get this right.

E

If the tapes always going to be in the same assembly, when you only have the two you just have member signature and type name, it's always going to be the same assembly. Why can't you reference the type hard.

E

Do you know what I mean like you know,.

A

Yeah I think it makes sense to all to help the middle one. Listen if you have the system to type one.

E

Right only out of a spring type, if you need to take in the string assembly.

B

You is another tip: don't have displaces different dpi settings, extra gig, impossible, um all right, so I heard type and then I heard biting flakes. What else was there.

F

Well, it was binding Flags what we actually used on the first attribute. We talked about no.

E

It was dynamic member yeah.

F

E

Excess member kinds, the.

B

Movie, though, all.

F

Right so I think we just deleted line 21. You.

E

Yes, let's finish line 525. This would replace string. Member signature.

B

Remove this one here is everything or this one.

A

Yeah 21 anyone.

B

F

In online twenty four, the third parameter replaces the first one true.

B

E

Need a string, you don't need a string member signature so delete that dynamic. That's member kind into the first slot.

E

And then you need one for 21 as well like that yeah.

D

B

That was the one never mind.

F

So then, now we need a dynamically accessed member kinds, nullable property and members. Signature becomes knowable as the property you.

E

We need a member kinds for number 20 as well the line Tony on this tape, or is that it feels like I'm, pushing it yeah for the.

F

E

F

If we, if we need it later, we can try adding it back, but who puts somewhere on their type. If you called something on my type, we need the whole rest of the type.

F

Then, like maybe it would make sense, but we I think we can bring that one back if we need it, I mean.

E

That would solve the case where we were like. We don't have a place to put this attribute.

F

Maybe, but if it was for for things like the debugger is going to directly reference this or the the debugger has a hook to call this member that you don't see like the linker would have already stripped it out, because the debugger didn't like it doesn't see any call to it. So the dynamic dependency doesn't resolve unless we said dynamically depending on yourself means you're a root, but that feels hacky.

F

So I think this covers the things we talked about.

B

All right, so we covered everything then, except for requires unreferenced code attribute so I guess we should cover that next week. Again then,.

E

B

Cool then I will and invite the same sort of people for next Thursday I believe there's an excuse to Zara taking, um and then we will also cover moenay's get GC info on this. We can do it over email and.

F

You know I just on the ASN reader/writer thing posted the diff of what the API looks like now that I've responded to feedback I, don't know what what mechanism we want to react that on, if Obed.

B

F

I mean we changed everything, but a lot of it is is simple, shape changes, so I, don't know if it's email or if it's response.

B

To what we said in the meeting there, nothing in it. We need to review with that. Give you if there was some feedback like think about X, and then you thought about X and you have a proposal for X I. Think that's different, but well.

F

Like replace the ref struct with static methods means here's what all the static methods look like now so yeah.

B

I think those are fine, I mean we usually don't do. Two passes might be usually tell people like here's the things you should probably fix and then that's the end of it. I mean it's only really for like. Oh, we don't know what the design would look like. I think everybody can visualize what having static methods would look like.

B

F

I did have one more concept: change with it. If I took the options to control some of the overloads with defaults, but anyway, I'm just take a look at the update. I just did to it and see how you feel when this is just more for the planning for the future meetings. So sounds.

B

Good then I think this is it goodbye everyone.

G