►
From YouTube: Languages & Runtime: .NET Community Standup - Dec. 12th 2019 - Source Generators with Andy Gocke
Description
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET Core, Languages, CLI, MSBuild, and more.
B
A
You're
under
playing
the
PM
roll,
the
one
thing
that
we
do
really
well
is
deleting
emails,
I
think
I.
Think
I
don't
get
enough
credit
for
that.
I
feel
like
that
is
trippy,
something
on
my
connect
this
year,
email
management,
it's
important
it
is,
and
the
usual
rule
is.
If
you
don't
mail
me
four
times,
it's
clearly
not
important
enough
for
me
to
take
a
look
at
that's
my.
A
These
days,
what
we
say
alright
so
then,
actually
let
me
try
to
figure
out
which
of
these
500
buttons.
That's
what
I
want
so
now
we
have
fancy
transitions
and
stuff
yeah.
D
A
In
case
you
didn't
notice,
but
we
shipped
Jornet
core
3.1
and
three
point.
One
is
amazing
for
two
reasons:
one
of
them
is.
It
reminds
me
of
windows
for
workgroups,
for
some
reason,
but
more
importantly,
it
is
the
LTS
version,
of.net
core
3x,
so
that
is
the
one
that
will
be
supported
for
a
very
long
time.
If
you
want
300,
you
should
consider
moving
to
3.1,
that's
kind
of
like
the
the
short
summary
of
it,
but
there's
also
blog
post.
A
That
goes
into
way
more
detail
and
all
the
stuff
that
we
have
done
in
300
as
well,
because
clearly,
if
you're
working
from
2
X
moving
to
3
1
is
also
interesting
for
all
the
300
features.
Obviously
the
big
ones
are
winforms
WPF,
which
I
think
you
may
have
heard
of
this.
Also
new
version
of.net
standard,
but
that's
not
like
the
killer
feature
of
the
platform.
I
would
say
at
this
point:
yeah
there's
a
lot
of
like
small
improvements
all
over
the
board.
So
it's
a
it's.
A
B
On
the
release,
I
think
we're
good,
there's,
there's
a
couple
things
around
it,
both
what
we're
doing
with
yesterday
that
changes
now
and
what
the
support
policy
is,
what
LTS
means.
You
said
you
know
it's
3:1
itself.
Yes,
it's
gonna
be
supported
for
a
while,
but
you
know
what
exactly
does
that
mean
and
what
are
the
implications
for
other
yeah.
B
Does
it
mean
so?
Lcs
is
long
term
support
and
we
have
a
support
policy,
we'll
bring
it
up
here
in
just
a
minute,
but
the
the
support
policy
says
that
something
marked
LTS
is
supported
for
three
years.
Something
that's
not
marked
out.
Yes,
is
also
called
current,
but
in
LTS
may
also
be
current,
so
I'll
just
say:
LTS
an
on
LTS,
neither
2.2
nor
3.0
or
LTS
2.1
and
3.1
r
LTS
going
forward.
B
We
expect
it
will
not
continue
to
be
dot
one
numbers,
so
that's
just
happens
right
now,
but
the
next
version
coming
out
November
of
2020
is
five.
Oh,
that
will
not
be
L
yes
and
then
six
Oh
coming
out
in
2021
November
will
be
LTS.
So
here's
the
days
when
things
go
out
of
support,
we've
got
the
right
thing
up
and
yes,
so
we've
the
important
thing.
B
The
important
pieces
here
is
that
dotnet
core
2.2
goes
out
of
support
on
December,
23rd
and
I
want
to
make
sure
we
understand,
and
we
explain
exactly
what
that
means.
So
we
will
not
stop
working.
If
you
have
it
on
your
machine,
it
will
all
continue
to
work.
We
will
do
absolutely
nothing
to
undermine
your
use
of
donek
or
2.2.
To
be
clear,
however,
we
do
regular
updates,
approximately
monthly
and
when
the
next
update
come,
which
would
predictably
be
January
around
Putsch
Tuesday
is
what
we
aim
to
match
that
with
then
you
will.
B
We
will
not
have
an
update
to
2.2
in
January,
because
it's
after
the
support
ends
and
if
that
release,
if
that
update
in
January.
If
that
patch
is
a
security
patch,
then
you
would
not
get
that
security
patch,
and
so
similarly
for
February
we
won't
have
a
and
in
March
the
actual
patch
tuesday
will
come
before
March
23rd.
B
So
you
could
expect
a
patch
if
there
was
one
needed
for
3.0
in
March,
but
not
in
April,
so
in
a
parting
in
April
will
just
be
providing
patches
for
2.1
and
3.1
until
we
get
around
to
5.0.
So
if
you
want
a
long
term,
I
don't
have
to
change
my
production
code.
Very
often,
then
you're
going
to
want
to
be
on
one
of
these
LTS
runtimes.
B
It
means
you
don't
get
the
latest
and
greatest
stuff,
though
so,
if
possible,
we
do
encourage
people
to
be
on
current
and
then
just
to
switch
over.
We
try
hard
not
to
make
breaking
changes,
but
we
have
we're
partnering
it
with
you
with
control
for
all
of
that
in.net
framework.
Somebody
just
updated
your
machine
and
did
a
Windows
Update
and
voila.
You
have
a
new
version
now
you
have
a
lot
more
control
of
that,
but
it
does
mean
that
we
have
to
have
these
conversations
yeah.
A
I
think
the
other
thing
that
is
interesting.
What
you
just
said
is
like,
because
don't
acquire
side
by
side.
The
cool
thing
is,
you
can
be
on
latest
for
some
projects
on
the
machine
and
you
can
be
on
LTS
for
the
moment
sure
the
mission-critical
things
whatever
right
so
like
the
nice
thing
is,
unless
you
don't
need
ephemeral,
you
basically
have
to
make
a
decision.
A1
experience
latest
and
greatest,
or
we
all
want
to
keep
my
existing
apps
running.
You
don't
have
to
make
that
choice
anymore.
A
B
That's
run
with
the
TFM
in
your
project
file.
That's
what
it
says,
what
version
you're
going
to
be
trying
to
target,
and
then,
if
that
versions,
not
on
the
machine,
there's
a
roll
forward
policy
which
you
can
instant
at
a
couple
of
places,
including
in
your
project
file,
including
on
a
machine.
If
you
have
something
you
need
to
run
and
the
person
owning
the
machine
needs
to
say
please
roll
forward
and
that's
under
the
runtime
roll
forward
policy.
If
we've
got
it
documented,
I.
B
B
All
right,
and
also
how
you
do
that
you
can
also
do
it
in
a
and
releases
it
releases,
dart
config,
there's
a
file
that
is
on
the
production
machine
and
you
can
modify
that
file
and
that's
also
going
to
allow
you
to
specify
that
roll
forward
from
the
perspective
of
the
owner
of
the
machine,
not
just
the
owner
of
the
author
of
the
code,
and
you
can
do
it
with
an
environmental
variables.
So
there's
multiple
routes
to
actually
doing
that
real
for
all
of
which
we
just
talked
about
is
about
the
runtime
right.
C
C
Obviously,
but
thinks
you.
C
A
One
question
from
Morton
is:
could
we
potentially
see
a
5.1
minor
update
between
500
and
600?
My
understanding
is
that
we're
not
planning
on
doing
that.
We
basically
try
to
stick
to
five
or
six
or
seven
or
eight
oh,
but
we
will
most
likely
end
up
shipping
previews,
obviously
in
between
and
I,
don't
know
how
many
people
supership,
but
of
course
you
want
to
get
bits
into
the
hands
of
people
to
actually
get
feedback.
I.
Believe,
though,
the
tooling
wise,
you
probably
ship
more
updates
than
just
major
versions
right
so.
B
Runtime
it'll
surprise
me
a
bit
if
we
do
a
dot
one.
In
the
middle
of
that
year
we
had
a
2.1,
because
we
were
looking
at
our
numbering
a
little
bit
differently
and
we
were
basic
basic
it
more
on
how
big
the
changes
were.
Gonna
be
now,
we've
decided
to
go
on
a
predictable
cycle
because
I
think
that's
better
for
people
and
with
that
change
with
only
a
year.
The
runtime
changing
within
a
year
is
highly
unlikely.
B
The
tools,
however,
will
change
approximately
every
quarter
and
for
many
reasons
we
wind
up
aligning
tools
like
with
the
visual
studio
release
cycle,
even
if
you're
not
using
Visual
Studio.
The
update
to
the
tools
happen
to
align
with
that
cycle.
So
it's
good
to
know
that,
and
we
expect
that
we
will
have
updates
going
forward
approximately
every
quarter
and
we
don't
own
that
schedule
visual
studio
we
just
align
with
their
schedule,
because
it's
one
of
our
major
delivery
vectors
is
inside
Visual
Studio.
If.
A
There's
one
question
that
keeps
coming
up
quite
a
bit
that
people
say
like:
why
is
not
LTS,
but
one
is
alts
and
the
short
answer
for
that
is
like
really
ballistically.
Lts
means
for
us
that
we
have
to
support
a
particular
snapshot
of
the
product
indefinitely
right,
and
so
we
already
said
that
one
is
LTS.
So
that
means,
if
we
should
be
now,
we
would
have
to
have
two
one
LTS
and
two
LTS
which
no
doubles
the
amount
of
branches.
You
have
to
maintain
him
on
dog
fixes.
A
We
have
to
push
out
and
that's
just
not
reasonable
for
forever
for
anybody.
So
what
we
ended
up
saying
is
like
yeah,
if
you're
on,
in
order
to
for
you
to
get
su
support,
you
have
to
move
to
the
3:1,
which
is
where
the
next
LTS
version
that
includes
all
the
bits
from,
but
also
more,
but
we
will
not
have
multiple
four
LTSs.
You
know
four
minor
versions
within
a
product
cycle
that
that
would
be
insane
and.
B
We
also
decided
that,
as
we
were,
as
we
were
working
on
the
policy
that
was
sort
of
going
on
about
the
same
time,
and
the
idea
is
that
we'll
have
a
LTS
about
every
two
years
and
it
didn't
line
up
exactly
but
kind
of
fell
in
that
that
two
year
period,
so
yeah
and
I
know
this
is
going
to
new
for
folks.
So
ask
all
the
questions
you
want.
This
is
actually
important
stuff
for
people
to
understand
and
I.
Don't
think
we've
done
a
brilliant
job
of
talking
about
it.
Now.
A
The
other
thing
I
want
to
point
out
is
like:
why
do
we
change
our
release
cycles?
If
you
look
at
the
dates
here
like
you
would
be
hard-pressed
to
predict
the
next
date
and
the
release
date
column
and
that's
what
we
bases
move
to
a
release,
cadence
where
we
said:
okay,
we
ship
once
a
year
we'll
ship
November
every
year,
and
so
that
also
means
given
the
LTS
policies,
which
basically
means
you
know
once
the
next
version
comes
out.
The
previous
run
is
supported
forth
in
two
more
years.
A
You
can
predict
now
when
things
are
happening,
because
you
know
when
the
dates
are
like
in
this
case.
It's
like.
Well,
you
don't
know
how
long
the
support
is,
because
they
basically
only
starts
ticking
when
the
next
one
is
out
and
the
really
state
is
unknown.
Then
it's
a
guessing
game.
How
long
you
actually
have
so
new,
more
alerts
or
predictable,
we.
B
Had
a
question
that
I
think
will
help
clarify
some
and
what
you're
saying,
which
is
that
the
question
is:
does
this
mean
600
will
replace
the
3-1
LTS
and
then,
if
so,
let's
see
what
does
that
say?
If
five-o
is
not
else?
Yes
right,
so
6o
will
be
the
next
LT.
Yes
and
part
of
what
that
means.
Is
that
six,
when
six
o
is
released,
that
starts
the
one-year
clock
ticking
on
3.1,
so
3.1
is
going
to
be
we're
getting
support
it,
which
means
you
get
patches
for
it.
B
We
will
release
patches
for
three
one
for
the
for
the
longer
of
it
was
it's
at
least
three
years
from
the
release
of
three
one
and
1
year
from
the
release
of
its
replacement,
which
will
be
6
o.
So
you
can
expect
well,
what's
a
stronger
than
that
we,
our
policy,
is.
We
will
support
3.1
for
3
years
from
its
release,
which
will
be
approximately
the
same
time
as
one
year
from
the
release
of
6.0.
B
A
So
Morton
is
asking:
can
you
talk
about
why
LTS
versions
have
breaking
changes,
but
no,
no
LTS?
Won't.
That
approach
makes
it
tricky
for
third-party
library
developers
to
ship
on,
for
instance,
three
Oh
before
three
one
comes
out,
but
the
lifespan
for
that
is
very
short
and
then
your
shortly
after
break-ins
with
two
one
release
and
customers
are
forced
to
move
to
three
one,
because
three
is
also
not
a
support
before
we
have
changes
to
releases
a
new
update,
I
think
so.
A
There's
it
I
think
that
this
duplication
here
the
way
Martin
asked
the
question
live
like
that
we
intend
to
make
making
changes
and
when
we
do
LTS
ins,
that's
normally
not.
What
ends
up
happening
is
what
ends
up
happening.
Is
that,
because
in
LTS
is
supported
for
a
very
long
time,
that
is
basically
the
last
chance
that
we
have
to
cut
things
out,
that
we
don't
want
to
support
a
long
time,
and
so
basically
I
think
the
one
that
that
you
may
refer
to,
as
in
the
wind
forms
blog
post.
A
That
is
pretty
much
why
you
see
these
these
kind
of
things,
but,
generally
speaking,
that's
also
why
I
think
the
new
release
cycle
will
help,
because
you
have
basically
an
LTS
every
other
year.
Then
you
have
major
app
versions
every
year
with
major
features,
and
that
gives
us
more
one
way
to
also
communicate
when
things
go
out
right
from
three
or
two
three
one.
It
was
only
a
couple
months.
That's
also
no
longer
the
case,
but
no,
you
have
basically
twelve
months
in
between
you.
B
Never
want
to
do
that
again.
You
never
want
to
have
three
months
between
releases
like
that.
It
was
difficult
for
for
you
to
uptake
and
it
was
difficult
for
us
to
pull
off
so
part
of
that
was
because
we're
transitioning
here
and
because
you
know
we
wanted
very
much
to
get
WinForms
and
WPF
into
people's
hands.
B
But
it's
kind
of
obvious
that
we
we
had
some
challenges
with
that
and
3oh
did
not
do
everything
we
wanted
to
do
in
WinForms,
and
so
we
really
needed
to
get
that
that
3-1
out
to
help
plug
the
holes
and
unfortunately,
as
plugging
the
holes
on
that
we
did
find
some
things,
and
so
it
was
not
as
smooth
as
we
would
like
it
to
be
right.
Alright,
I
do
want.
E
D
B
B
B
So
we
kind
of
wince
a
little
bit
at
that
because
there's
one
thing
you
might
not
be
expecting.
That's
actually
one
of
the
challenges,
but
you
can
do
it
ahead
of
time,
while
you're
in
four
or
five
and
that
can
make
can
smooth
the
transition,
and
so
that's
working
on
your
project
file.
So
the
project
system
is
new
in
we
switched
it
and
you
can
run
the
new
project
system
against
four
five
and
do
some
of
those
updates,
particularly
around
packages.
Are
you
good
at
talking
about
actually
changing
to
from
packages
config
to
project
file?
B
A
A
Say
migrate
to
that
reference
that
that's
the
easiest
way
and
then
you
from
there
you
basically
just
have
to
migrate
the
project
file
for
which
we
also
have
a
tool.
If
you
go
to
or
dotnet
organization
on,
github
there's
a
new
repo
called
try
convert,
and
that
is
basically
a
command
and
tool
that
you
can
use
to
mark
on
your
project
files,
which
gets
you
pretty
close.
B
Might
work
and
it
might
just
not
work
so
it's
a
it's
set
up
for
the
easy
case,
and
a
lot
of
you
are
in
the
easy
case
and
a
lot
of
you.
This
will
save
a
ton
of
time
for
and
a
lot
of
you
that
are
not
in
the
easy
case.
It
will
save
a
bunch
of
grunt
work
for,
but
it's
not
a
push
the
button
and
it
will
guaranteed
work,
it's
a
push
the
button
and
it
might
work
yeah.
A
A
What
the
tool
looks
like
so
this
is
basically
the
github
page
and
then
I
think
there's
a
there's,
a
sample
in
here
too,
where
basically,
you
just
run
this
tool
and
then
here's
the
command
and
options
that
you
have.
Basically,
in
short,
the
tool
will
work
reasonably
well,
like
I
have
used
it
on
my
own
projects,
quite
a
bit,
so
the
more
standardized
or
standard
the
your
project,
father's
meaning.
A
If
you
make
customizations
yourself
of
msbuild,
it
will
have
much
much
harder
time
if
it's
basically
vanilla
a
file,
new
project
plus
right-click
modifications
like
adding
references
and
source
files
like
I've,
not
seen
it
not
working
like
there's,
always
some
corner
cases
where
you
have
a
particular.
You
know
special
projects,
but
the
one
thing
that
I
poured
it
was
console.
Apps,
just
fine
glass
lab
is
just
fine,
UI
ABS,
just
fine,
it's
rather
a
lot
more
as
web,
because
web
is
a
lot
more
complicated.
A
The
way
the
project
files
are
being
done
there,
but
you
know
for
class
libraries
and
and
in
your
IEPs
and
console
apps.
If
it's,
basically,
when
the
define
your
project
kind
of
thing,
then
I
have
not
seen
any
problem
so,
like
I,
think
for
the
vast
majority
of
you
will
probably
just
work
fine,
but
there
is
of
any
port
right
you
have
to
you
know.
The
behavior
also
has
changed
right
like
once
you
once
you
move
to
donate
Corp,
you
know,
make
sure
your
money
unit
tests.
B
I
am
is
a
tool
that
you
can
use
ahead
of
time
to
find
out
how
many
things
that
you
may
be
using,
that
might
be
not
there
and
running
that
ahead
of
time.
I
can
show
you
if
you
have
a
problem,
give
you
a
comfort
factor.
If
you
don't
have
problems,
so
that's
definitely
worth
doing
first.
So
do
we
have
anything
else
going
on
that's
new?
We
got
a
couple
people
talking
about
conversion,
which
is
great.
A
A
This
is
one
thing
that
we
changed
and
we
basically
said
the
project
file
is
source
code.
Maybe
they
did
a
bunch
of
work
and
the
SDK
start
projects
to
make
it
so
that
it's
not
four
hundred
lines
of
a
lot
of
goo
so
moving
forward.
You
should
treat
your
project
files
as
source
code
and
there's
a
bunch
of
things
you
can
do
to.
You
know,
repeat
not
repeat
yourself,
you
know,
factor
things
out
and
making
things
customizable
murad
to
edit
a
bunch
of
properties
into
the
project
file
so
that
you
can
actually
customize.
A
For
example,
all
NuGet
packages
are
being
built.
You
know
what
assembly
information
you
have
is
no
longer
generated
in
the
CSV
file.
It's
actually
part
of
the
project
file,
which
means
you
can
now
use
sharing.
You
can
actually
compute
videos,
you
can
compute
version
numbers
as
opposed
to
writing
them
into
the
text
files
yourself,
and
so
this
is
all
stuff
you
can
do
and
then
it
also
means
that
moving
forward.
A
B
We
really
recommend
people
use.
The
latest
SDK
can
build
all
previous
run
times
and
we
confuse
people
on
that
by
releasing
stuff
like
a
2.1
to
800
and
that
that
led
to
a
certain
amount
of
confusion.
So
when
you're
working
with
the
tools,
the
only
difference
between,
for
example,
I,
think
I'll
get
this.
This
set
right
if
I
don't
apologize,
but
two
dot,
one
dot,
402
dot
e
dot,
800
the
only
difference
between
those
two
series,
both
of
which
went
out
adjacent
to
16.2.
B
The
only
thing
different
between
them
is
one-
is
compiled
against
the
two
one
runtime
and
one
is
compiled
against
the
to
to
run
time
and
when
you're
building
you
don't
care.
What
run
time
your
tools
were
compiled
against.
We
had
a
different
idea
in
the
past
that
maybe
you
would
only
want
to
one
on
your
machine
and
we
were
making
things
easier
and
as
a
but
as
a
result,
we
wind
up
with
and
it's
kind
of
a
mess
in
our
downloads
and
very
difficult
to
understand
the
SDKs
so
going
forward.
B
B
We
are
not
going
to
be
updating
those
in
the
same
way
that
we
did
before
we're
going
to
be
updating
just
the
tip,
and
so
you
may
need
to
pick
up
a
runtime
in
order
to
have
that
be
fully
patched
and
I
am
working
on
a
blog
post
on
that.
But
the
important
thing
here
is
that
you
there
is
not
a
2.1
or
a
2.2
that
aligns
with
either
Visual
Studio
16
3
or
16
4.
B
So
the
reason
is
that
the
tools
that
would
align
with
those
are
the
3.1,
oh
I'm,
sorry
3.0,
100
or
3.1-
that
100
tools
and
those
tools
are
released
only
compiled
against
3.1.
So
if
you
want
to
target
and
older
runtime
just
get
that
runtime
and
then
you'll
have
the
single
copy
of
the
tools,
which
would
be
a
much
simpler
story
to
explain
to
people
going
forward
for
you
to
be
able
to
understand
what
you
want
to
get
off
of
our
website
and
then
separately
get
the
runtime
that
you
actually
do
want
to
target.
So.
B
C
B
C
D
B
C
B
You
do
want
that
to
be
patched,
that's
you
know
it's
the
right
thing
to
do
and
so
then
you
can
go
into
the
willow
I'm.
Sorry,
the
Visual
Studio
installer,
which
we
lovingly
call
willow,
but
the
Visual
Studio,
installer
and
individual
components,
and
you
can
check
that
and
you
can
get
what
you
need
and
there
you
go
and
then
for
the.
If
you
work
on
the
CLI,
you
want
to
get
it
from
the
website,
then
you
just
need
to
go
into
the
2.1
or
2.2
pages
and
grab
the
latest
one
time.
Yeah.
B
A
C
A
Guess
the
the
interesting
thing
is,
you
know
it
zoomed.
Finally,
is
this
yellow
banner
here
right,
because
basically,
what
I'm
getting
right
now
is
this
thing
that
is
compatible
with
the
latest
version
of
vs,
basically
right
and
then,
if
I
want
another
version,
I
have
to
click
on
this
guy
and
then
here's
where
I
get.
C
The
breakout
yeah,
if
you're,
always
if
you're
using
an
older
version
of
Visual
Studio,
then
obviously
the
tools
that
ship
in
Visual
Studio
will
be
out
of
date
with
the
newer
version
of
the
SDK.
So
there's
a
bit
of
mix
and
matching
there,
which
is
why
the
recommendation
is
always
also
be
on
the
newest
version
of
Visual
Studio
right.
B
So
the
break
that
can
happen
there
is
Visual
Studio
because
it's
not
tested
with
a
higher
version,
the
little
studio,
obviously
not
tested
with
the
future
its
tested
with
today,
when
it's
released,
so
something
like
16.3
is
tested
against
3.0
to
100.
So
therefore,
this
actually
mark
in
it
that
says
the
highest
it
will
run
against
is
3.0
at
100
and
the
purpose
for
that
gold
bar
there
that
that
warning
is
to
tell
you
that
if
you're
running,
update,
3
Visual
Studio
2019
update
3,
which
we
call
16
3.
B
If
you're
running
that
and
you
down
the
16
for
theirs,
you
don't
you
haven't
downloaded
the
right
thing.
It's
particularly
serious
in
Visual
Studio
for
Mac,
which
we
broke
them
in
one
of
the
2.2
releases,
and
this
is
a
warning
to
help
keep
people
from
getting
broken.
You
only
would
have
a
problem
if
you
uninstalled
things
from
your
visual
studio
and
then
you
went
and
you
were
trying
to
reinstall
them.
B
It's
a
fairly
small
case
where
that
matters,
but
the
other
thing
in
the
transition
is
that
we
failed
to
see
the
impact
of
not
releasing
two
dot
one
dot
800,
which
is
out
of
support
the
two
dot
one
dot.
Eight
X
X
series
is
out
of
support
and
that's
also
2.2
4,
X
X,
and
so
at
the
moment
we
have
a
different
highest
and
latest
so
I
recommend
people
use
802
and
then
install
the
newest
runtime.
If
you're
in
that,
we'll
fix
that
in
January
will
not
fix
that.
B
But
if
you
go
to
the
website,
it's
a
little
confusing
because
we
released
an
update
to
607
I
think
it
is.
But
we
released
an
update
to
the
600
series,
but
not
the
800
series
and
that's
because
eight
hundreds
out
of
support,
but
because
it's
the
highest
I
think
we're
gonna
figure.
We
plan
to
fix
it
in
January,
because.
C
B
Doing
to
one
development:
that's
great!
If
you
don't
have
a
global
Jason,
you
can
put
two
1s,
take
any
machine,
a
three
one:
SDK
on
your
machine
target,
2.1
and
you're,
using
the
3.1
sdk
right
now,
so
it
uses
the
highest
one.
That's
sitting
on
your
machine,
so
you
do
not
need
2.1
sdk,
unless
you
have
a
specific
reason
that
you
need
it,
which
is
generally
because
you
have
a
I'm,
a
spill
property
that
somebody
ran
into
later
or
some
sort
of
a
weird.
You
know
for
yet
yeah.
C
B
A
We
didn't
move
fast
enough
now
we're
moving
faster,
what
that
means
more
trains,
and
that
means
you
need
to
basically
look
at
the
train
schedule
to
understand
like
which
thing
goes
where
right
and
that's
not.
Everybody
wants
that,
but
the
easy
fixes,
if
you
just
want
to
move
fast-
and
you
don't
mind
that
sometimes
you
have
your
honor
on
a
version
that
we
introduced
to
break
and
change
then
always
being
our
latest-
is
a
really
good
idea.
So.
B
B
B
A
A
C
He's
not
absolutely
we're
just
gonna
omit
random
ones
that
this
doesn't
matter.
It's
all
Shaw's.
You
only
grab
a
saw
and
that's
it.
I
love.
B
So
one
of
the
interesting
things
about
when
something
we
said
we
were
going
to
talk
about
here
today
is
that
I'm
on
the
language
design
team,
but
I
was
traveling
and
I
had
a
couple
things
going
on,
so
I
missed
a
set
of
meetings
where
I
know
nothing
about
what
we're
doing
with
source
generators
and
some
of
that
work
bills
on
things
that
was
done
two
or
three
years
ago
in
the
language
design
team
before
I
joined
Microsoft
so
other
than
the
fact
that
I've
had
a
lot
of
opinions
in
the
history.
B
C
So
yeah
I
can
give
like
a
brief
history
of
of
the
feature
and
kind
of
the
problem
space.
So
the
the
interesting
thing
is,
we
looked
at
this
probably
two
to
three
years
ago
and
some
people
might
have
seen
the
original
discussions
and
some
of
the
original
design
documents.
We
had
a
prototype
that
was
built
by
another
developer
on
the
seashore
compiler
team
chuck,
and
we
had
some
language
features
that
were
proposed
in
the
language
design
team
to
kind
of
support.
C
This
general
feature
called
source
generators
which
I'm
not
particularly
describing
what
it
is,
because
it
honestly
wasn't
fully
thought
about
what
it
was
like.
This
was
an
exploration,
so
we
wanted
to
say:
hey,
there's
a
lot
of
times
where
I'd
like
to
generate
some
code
and
it's
not
as
easy
as
it
should
be.
The
answer
is
a
lot
of
people
generate
code.
Today,
it's
not
as
though
we
don't
already
have
source
generators.
It's
just.
We
have
source
generators
and
probably
ten
different
forms
across
ten
different
products.
C
The
most
common
thing
is
you
do
it
in
msbuild,
you
add
like
a
separate
pre-compile
step
or
something,
and
then
because
msbuild
pre-compile
steps
can
have
other
pre-compile
steps
inserted
and
in
the
middle
of
them.
You're,
like
you,
just
pray
that
you're
not
gonna,
get
conflicts
with
like
another
source
generation
thing
and
and
there's
tons
of
source
generated
code
in
the
in
the
libraries
today
like
res
x,
for
example,
resource
files
or
assembly
info
right.
That's.
E
C
Modern
SDK,
like
that,
writes
out
a
c-sharp
file.
You
know
that
C
sharp
file
gets
included
in
your
compilation,
etc,
and
there
are
a
number
of
problems
that
we
saw
that
weren't
strictly
language
problems.
It
wasn't
people
being
unable
to
express
a
specific
like
type
theory
problem
or
something
inside
C
sharp.
It
was
more
like
here's,
this
domain-specific
code
that
I
have
to
write.
It's
really
laborious,
it's
really
hard
to
maintain
and
all
of
its
all
that
could
be
automated.
There's
really
no
reason
why
I
should
have
to
handwrite
this
every
time.
C
So
we
started
exploring
the
space
and
we
ended
up
with
this
idea
of
well
what
if
we
could
just
add
source
files
to
the
compiler
at
Build
time,
and
rather
than
going
through
a
mess,
build.
The
compiler
would
kind
of
provide
this
mechanism
for
you
to
add
source
files
directly
like
and
analyze
our
plugs
into
the
compiler
directly,
and
then
all
the
analyzers
are
run
when
the
compiler
builds.
And
then
we
also
went
to
language
design
and
said
hey.
C
C
Partial
classes,
most
notably
it
just
allows
you
to
take
a
class
and
splits
declaration
among
multiple
files.
The
idea
was
that
you
could
use
it
when
you're
writing
code
manually,
but
also
you
could
use
it
when
you're
generating
code.
So
you
write
part
of
your
code
yourself
and
then
you
have
some
kind
of
source
generator
come
along
and
write
out
a
partial
class
for
one
of
your
existing
classes
and
kind
of
add
functionality,
and
you
just
have
like
a
build
time
thing
that
that
spits
out
strings
or.
B
C
C
C
Sometimes
you
want
to
generate
code,
and
you
have
a
lot
of
problems
that
you
wrote
some
code,
but
it
wasn't
exactly
the
the
code
that
you
wanted
to
write,
and
so
we
said,
okay,
we
can
do
replace
an
original
where,
in
you
write
the
method,
you
write
your
own
method
in
your
code
marked
with
original,
and
then
you
spit
out
a
new
source
file
and
it
has
the
replace
keyword
on
the
new
method
with
the
same
signature.
And
the
idea
is
that
the
new
method
replaces
the
old
method
can.
C
The
new
method
call
the
old
method.
There
was
some
proposals
around
mechanisms
for
that
it
got
very
complicated
yeah.
The
answer
is,
you
have
all
of
the
right
questions,
because
we
had
those
questions
too,
and
it
started
getting
very
complicated
very
quickly,
but,
moreover,
as
we
started
exploring
this
more,
we
realized
they're
kind
of
huge
impacts
on
the
rest
of
the
ecosystem.
C
One
of
the
key
things
is
that
you
need
to
have
the
source
generation.
You
need
to
have
the
generated
files
for
a
wide
variety
of
just
bog-standard,
c-sharp
analysis
like
intellisense
or
debugging,
or
editing
continue
or
like
any
number
of
Visual
Studio
features
they
all
started
depending
on
source
generation
and,
moreover,
it
got
really
bad,
because
if
source
generators
could
run
at
any
time
and
your
code
could
be
kind
of
half-formed
at
any
time,
then
the
question
of
when
does
Visual
Studio
generate
source
essentially
came
down
to
every
keystroke,
and
that
was
not
performance.
C
B
C
B
C
All
three
years
ago,
and
so
we
kind
of
stepped
back
and
we're
like,
we
can't
just
throw
this
out
there
and
hope
everything
works
out-
that
we
have
to
have
a
plan
for
how
we're
going
to
make
stuff
like
the
entire
IDE
work.
It
doesn't
necessarily
it's
not
like.
We
have
to
build
every
piece
all
at
once
and
that
we
can't
ship
anything
until
it's
done,
but
if
we
just
throw
stuff
out,
then
we're
gonna
end
up
in
a
really
bad
there's
a
good
chance.
C
We
end
up
in
a
bad
place
that
we
can't
fix
right,
and
so
that's
just
a
general
language
design
principle
and
a
great
example
of
this
is,
like
extension,
methods
where
we
said.
Oh,
we
should
add
an
extension
system
so
that
you
can
write
a
method
on
a
class
that
you
didn't
write
or
that
you
have
in
a
separate
file
just
for
organizational
reasons
or
whatever,
and
people
immediately
came
back,
and
this
is
a
really
common
request.
C
These
days,
I
should
be
able
to
write
extension
properties,
yes
or
extension
like
static
extension
methods
like
you,
extend
onto
a
static
class
or
something
how
about
the
extension,
constructor,
I
think
extension
constructors,
like
all
of
these
things
right
and
core
FX,
just
bugs
us
all
the
time
for
this.
So
the
the
problem
with
that
was
that
we
chose
a
specific
syntax
which
uses
the
this
keyword
in
the
parameter
list.
Mm-Hmm
properties
don't
have
a
parameter
list.
Yes,
well.
C
So
the
answer
is
we
actually
drove
ourselves
into
kind
of
a
syntactic
hole
and
if
we
had
probably
asked
ourselves
so
how
would
we
add
extension
properties?
The
answer
is,
we
might
have
done
extension
methods
completely
differently
right
and
so
we're
thinking
about
that
now
and
we
have
kind
of
plans
for
extension
methods
and
we
have
ideas
about
extension
properties
and
all
these
other
things.
But
they're,
probably
gonna,
look
a
lot
different
from
extension
methods
right
because
we
didn't
kind
of
go
ahead
and
do
that
yeah,
avoiding.
C
C
A
Mean
we
have
done
crazy
stuff
before,
but
I
think
like
in
the
Donna
Corby
one-time
friend,
the
Araneta
team
experimented
heavily
with
intercepting
the
compilation
unit
and
and
basically
writing
with
whatever
they
wanted
to
write.
The
problem
of
these
kind
of
things
is
that
you
can
also
know
create
dialects
of
the
language
where
you
have,
like
you
know,
fake
keywords
with
attributes
and
other
stuff
and
then
magically
we
provide
stuff.
A
The
problem
is
not
so
much
that
you
can't
do
it
I
mean
you
can
do
it
today,
but
just
we're
not
writing
a
command
line,
app
that
just
uses
walls
indirectly,
but
the
problem
at
that
point
becomes,
as
you
said,
like
the
entire
ecosystem,
my
tooling
and
all
the
other
stuff.
Just
that
just
falls
apart
and
I
mean
we've
seen
this
in
other
areas,
I
mean
t4
is
decent,
but
the
problem
is
that
again,
like
the
the
design
time,
experience
was
kind
of
left
as
an
exercise
for
the
reader,
and
then
it's
like
yeah.
A
Of
course
it
gets
the
job
done,
but
boy
is
it
ugly,
right
and
I
think
that's
kind
of
the
same
problem.
I
think
across
the
board
I
mean
C++
templates
are
powerful,
macros
are
powerful,
but
yeah
the
design
time
experience.
Let's
yeah
it's
a
bit
like
yeah,
it's
great
when
it
works,
but
it's
really
terrible
when
it
doesn't.
B
There's
two
problems
with
the
work
that's
been
done
before
and
you
know
it's
a
space
I've
been
in
for
a
really
long
time
and
a
couple
things
happened.
One
is
that
everything
else
we
do
has
changed
in
a
way
where
we
need
to
generate
code
less
often
if
you're
writing
normal
business
applications.
So
it
was
very
different.
20
years.
C
B
B
That
was
all
done
by
producing
text,
which
means
that
you
don't
have
a
valid
compilation.
You're
then,
oh,
by
the
way,
we'll
also
give
you
some
text
on
this.
If
you
want
to
look
at
it
for
debugging
and
stuff,
so
I
think
it's
it's
a
great
time
to
be
looking
at
it
one
more
time
and
I
guess:
I'm
curious.
You
said
you
you're,
not
sure
that
we
need
replace
and
replace
was
harder
to
do
than
you
thought.
I'm.
Definitely
one
of
the
people
you.
C
B
For
it,
but
I
guess
I
had
a
lot
of
change
in
the
world,
I,
don't
how
hard
a
task
today,
but
but
other
than
that
you
talked
about
some
other
problems
like.
How
are
you
going
to
get
this
actually
accomplished
in
a
way
that
is
not
going
to
throw
a
performance
out
the
window?
How
do
you
solve
that
problem?
Can.
A
C
C
C
D
C
C
Shows
you
the
corner,
yeah
yeah,
so
the
the
idea
is
that
that
I
notify
property
changed,
is
kind
of
the
the
old
hand
in
this
entire
debate,
like
that,
if
you.
B
C
Solve
that
you're,
you
fail
it,
so
you
have
to
solve
this
one.
It's
one
of
the
biggest
requests
for
a
long
time
for
language
features
for
a
long
time,
and
so
it's
also
the
one
that
everybody
was
pushing
for
replace
original
because
the
initial
idea.
Well,
let
me
let
me
back
up
a
second
and
talk
about
where
we
landed
in
the
new.
C
If
you
can't
replace
files,
if
you
can't
replace
methods,
how
do
you
do
I
notify
property
changed,
because
you
want
to
like
insert
calls
or
something
into
those
methods,
and
the
answer
is
that
you
actually
don't
need
to
replace
the
method.
So
this
is
the
example.
Implementation
of
inotify
property
changed
from
the
dotnet
Docs
right.
This
is
the
just
bog-standard.
C
C
C
You
have
to
write
most
importantly,
you
kind
of
have
to
write
out
the
getter
and
setter
manually
every
time,
because
you
need
to
insert
this
property
change
call
into
the
setter
and
so
replace
original.
The
idea
was
Oba.
We
can
kind
of
like
replace
the
original
thing
with
a
on
property,
changed
call
and
then
call
the
old
thing,
and
that
was
how
we
kind
of
replaced
or
that's
how
we
kind
of
inserted
into
the
code
structure
there,
and
you
would
think
that
it
would
be
very
difficult
to
do
without
replace
original,
but
it
turns
out.
C
Not
only
is
it
not
that
difficult,
but
it's
shorter
code,
if
you
don't
do
it
that
way,
so
if
you
scroll
down
I,
have
some
like
sample
code
of
what
it
would
look
like
with
the
source
trainer
design
that
we're
looking
at
today,
I've
created
this
kind
of
phantom
attribute
called
notify
changed
you
get
that
from
somewhere,
probably
from
the
source,
generator
library
itself
that
that
implements
inotify
property
changed.
It's
got,
this
special
notify
changed
attribute
and
the
idea
is
the
source.
C
That's
the
code,
the
write
that
you
would
write
by
hand-
and,
if
you
add
this
and
the
idea,
as
you
add,
this
notify
changed,
and
this
is
all
kind
of
the
pattern
of
the
source
generator,
the
sort
there's
nothing
mandated
here
by
the
language
or
the
design.
It's
just.
This
is
how
powerful
the
feature
is
that
you
can
kind
of
yeah
thanks
for
fixing
that
up
yeah.
B
C
The
generator
looks
for
this
property,
it's
applied
to
the
field,
and
then
it
knows
that
your
it's
inside
an
eye
that
implements
inotify
property
changed,
which
means
it
knows.
Oh
well,
I've
got
to
implement
the
property
changed
event
because
that's
required
by
the
interface
and
then
I
have
all
these
fields
and
they
need
to
have
the
property
changed
code
that
that
generates
for
them.
So
the
generator
itself
just
writes
out
your
properties
for
you,
so
you
don't
even
need
to
write
out
any
of
the
properties
you
don't
need
to
replace
original.
C
C
The
idea
is
that
it's
it's
a
really
simple
system.
Actually,
it
just
changes
compilation
to
be
two
phase:
the
first
phase.
We
have
the
compilation,
that's
all
the
user
code,
and
then
we
have
the
set
of
generators
that
were
passed
in
just
like
we
have
analyzers.
In
fact,
the
idea
is
that
generator
assembly
is
essentially
an
analyzer
assembly.
We
pass
the
compilation
to
all
of
the
generators
they
get
to
examine
it.
They
get
to
spit
out
strings.
C
That
is
that
our
source
code
and
then
we
take
all
of
those
strings,
all
those
additional
text
files
we
parse
them.
We
add
them
to
a
second
compilation
that
contains
all
the
user
files
and
all
the
generated
files,
and
that's
the
final
compilation
and
the
the
cool
idea
there
is
that
there's
nothing
different
in
the
language
after
you
do
that.
C
This
is
just
c-sharp
how
you
debug
is
well
the
generated
files
are
included
in
the
compilation,
they'll
be
written
out
to
disk
as
well,
so
you
can
see
them
they're
real
files,
they're
on
disk
there
right
there,
as
you
debug
through
when
you
hit
a
generated,
call
you
go
into
that
generated.
Call.
There's
like
no
magic
here,
there's
no
secret
hooks
or
anything
calls
our
calls.
They
call
into
the
appropriate
thing
and
when
you
debug
through
them,
you
debug
through
the
source
right
so.
B
C
E
B
B
C
B
So
it's
about
2002
I've
been
acting
for
a
different
background
for
for
read-only
files,
and
maybe
we
can
get
that
you
know
around
the
same
time,
but
then
we
also
have
where
it's
needed.
We
do
have
the
normal
partial
method,
support
that
we
already
have
for
partial
classes.
So
when
there
is
a
known
piece
that
could
be
needing
to
be
customized,
then
we
already
have
that
capability
in
in
the
the
partial
class
system,
yeah.
C
And
in
fact,
you
can
see
that
one
of
the
changes
that
I
made
to
this
to
the
original
class
was
I
made
it
partial
and
the
reason
is
because
the
generated
code
is
in
a
partial
class
and
the
original
code
is
in
a
partial
class.
So
the
idea
is
that
there
should
be
very
little
magic
here.
You
shouldn't
be
scared
about
generated
files,
because
you
can
see
them
they're
part
of
your
compilation.
All
of
your
tools
continue
to
work.
It's
all
real
code,
one.
A
C
A
That
thing
is
not
necessarily
free
of
errors
right,
so,
for
example,
in
your
case,
somebody
else
like
I
I
lead
generator
to
generate
my
properties
right,
but
then,
in
my
own
user
code,
I'm
I
already
referenced
them
in
because
I
expect
them
to
be
generated.
So
that
means
the
first
pass
effectively
will
have
eros
of
things
that
don't
exist.
Yeah.
C
In
fact,
the
task
of
a
compiler
developer
is
not
compiling
correct
code,
but
you
do
that
once
you
compile
incorrect
code
hundreds
of
times
until
people
fix
all
their
errors,
then
you
actually
compile
the
correct
code.
So
we
have
a
pretty
robust
error
recovery
system.
Today
we
might
need
to
do
more
work
right.
E
A
I
mean
act,
one
of
the
things
that
I
find
frustrating
with
the
C++
macros,
for
example,
is
that
you
know
my
current
example
would
be.
You
know
the
old
win32
world.
There
was
these
macros
that
define
message,
maps
which
effectively
just
compile
down
to
generating
methods
and
the
globalize
switch
statement.
But
the
problem
is
there's
like
multiple
macro,
so
it's
like
beginning,
macros
and
and
macros
and
like
macros
in
the
middle.
A
If
you
up
one
of
those,
you
get
effectively
compiler
errors
that
that
are
unintelligible,
but
you
have
to
know
that,
oh
because
I
didn't
arrange
them
correctly
right.
So
in
this
case
the
question
would
be:
if
I,
if
I,
let's
say
I,
forget
the
I,
forget
the
you
know:
I,
don't
mark
this
partial,
for
example,
or
I.
A
C
C
You
got
to
play
a
little
bit
of
compiler
developer
here
and
foresee
the
problems
and
kind
of
try
and
produce
reasonable
error
messages
that
tell
people
hey
this
class,
wasn't
partial,
so
I
can't
generate
the
appropriate
code
right
and
then
you
can
produce
that
error
and
if
the
generator
produces
the
error,
then
Summa
bleah.
We
won't
actually
go
on
to
the
second
phase
of
analysis.
E
A
A
Integration,
where
you
can
say
I
can
even
see
that
your
reference
person
dot,
you
know
a
name
as
a
property
in
that
capital
n,
but
then
I
can
also
say.
Well,
you
didn't
mark
the
field.
So
probably
you
should
do
that.
It's
so
like
the
the
author
of
the
thing,
because
there's
access
to
the
compilation,
it
can
actually
do
things
that
you
wouldn't
be
able
to
do
in
macros,
because
you
don't
have
the
ability
to
inject
an
intelligent
code
right.
You
just
have
to
allow
the
developer
to
not
screw
it
up
now.
B
Probably
all
most
generators
like
you've
got
two
class
names
and
ones
not
partial,
and
that
probably
should
have
been
partial
kind
of
thing
yep
and
then,
potentially,
even
maybe,
with
some
the
template
author,
having
throwing
in
a
little
bit
of
intelligence
or
calling
a
library
to
do
some
checks
or
something
like
that,
and
then
there's
some
checks
that
are
just
about
is,
is
my
metadata
ready,
because
the
whole
idea
here
you
know
generation
is
always
metadata.
Plus
template
equals
output,
and
here
the
metadata
is
the
Roselyn
compilation
of
the
source.
B
As
the
user
wrote
it
that's
what
the
metadata
is
and
and
I'm
having
to
like
one
piece
of
that
I
want
to
kind
of
get
back
to
exactly
what
that
means,
and
then
the
code
excuse
me
the
code.
Does
that
the
alter
alteration
based
on
the
template
and
has
the
output,
and
so
one
of
the
things
that
we
get
in
that
in
that
process
is
one
of
the
problems
that
you
potentially
have.
B
We
source
generators
is
order
of
operation,
so
one
of
the
ways
that
generators
have
been
considered
before
is
that
they
work
directly
against
the
compilation,
which
means
that
one
can
change
the
metadata
for
the
next
and
the
order
in
which
they
occur
becomes
hyper,
critical
and
there's
a
lot
of
really
hard
things
that
can
happen
in
that
stream.
It's
too
much
from
somebody
who's,
a
cogeneration,
geek,
Annie
and
I.
B
Both
are
by
the
way
we
have
very
different
backgrounds
on
cogeneration,
and
one
of
the
things
we've
talked
about
is
the
fact
there's
so
much
less
need
of
it
than
there
was
20
years
ago,
but
now
you're,
saying
you're
just
creating
new
files,
and
if
your
files
conflict
with
somebody
else's
new
files,
then
you're
gonna
have
to
figure
that
out.
But
it's
going
to
be
an
obvious
conflict
in
the
created
files
that
somebody
can
figure
out
how
to
resolve.
B
So,
if
I
create
a
partial
and
it
has
a
print
method
and
you
create
something
that
creates
a
partial
that
has
a
print
method
and
we
they
have
the
same
signature
and
they
collide.
It's
an
obvious
thing
for
the
for
the
owner
of
the
of
the
code.
That
said,
I
want
your
templates
and
your
templates
and
they
can
resolve
it,
which
you
can't
do
if
you
have
a
pipeline
style
of
generation,
so
really
like
that
I'm
not
quite
sure
yet.
B
I
was
one
of
the
people
who
asked
for
replace
not
not
quite
sure
on
that
yet,
but
I
do
think
it's.
It
may
be
a
really
good
way
for
us
to
finally
get
some
source
generation
support
in
the
in
the
inside
of
the
c-sharp
compiler.
So
there's
been,
a
lot
of
ideas
have
come
along
that
I've
been
like
it's
not
all
the
way
there.
It's
just
not
all
the
way
there,
but
this
could
this
could
work.
We
had
some
questions.
We
should
go
to
questions
yeah.
A
I
mean
one
of
the
questions
was
like
because
it's
generated
code
like
it
doesn't
live
in
version
control
right
is
in
the
obj.
Pholis
was
technically
not
checked
in
right.
So
how
does
that
work?
When
you
have
a
production
like
that?
You
just
do
bug
production
code
base
like
how
do
you
get
access
to
the
source?
Oh.
C
A
Think
it's
already
part
of
the
source
link
thing
to
say:
if
the
file
is
not
under
version
control
or
if
it's
part
of
the,
if
it's
excluded,
basically
by
I,
get
ignore,
it
will
be
embedded
right.
So
it's
basically
you
embed
the
ones
that
are
not
in
source
comes
when
the
ones
that
are
in
source
control.
You
just
use
the
linking
yeah.
C
There's
heuristics
that
say:
oh,
is
this
file
generated
then
embedded
inside
the
PDB
by
default,
right
and
I.
Think
that
and
that's
those
are
set
of
features
that
have
kind
of
come
along
over
the
years
at
one
by
one,
really
right,
so
we're
basically
that's
the
other
thing
like
we're
kind
of
just
taking
advantage
of
a
lot
of
progress
that
has
been
made
and
just
looking
back
on
it.
C
We
started
to
realize
this
thing
is
so
powerful,
even
with
all
these
restrictions,
the
restrictions
that
seem
like
heavy
handed,
and
yet
it's
still
really
really
powerful
right.
I've
looked
at
a
lot
of
examples
and
it
turns
out
you
can
write
most
of
them
without
you
just
have
to
be
a
little
bit
clever
about
it
right
and
that's
where,
like
not
modifying
code
comes
in
so.
C
That's
a
great
question
and
I
think
that
it's
probably
gonna
differ
based
on
exactly
who
you
are
and
what
you're
doing.
There's
certainly
I
think
that
there's
certainly
use
case
where
you
would
want
to
check
it
in.
We
still
have
a
little
bit
of
work
to
do
to
figure
out
a
little
bit
about
how
to
match
up
code
that
that
was
previously
generated
with
code
that
will
be
generated.
C
So
naturally,
if
you
don't
include
the
generated
code
in
your
source,
as
is,
we
still
need
some
way
to
pass
it
to
the
compiler
to
say:
hey,
you
there's
a
generator
for
this
compilation.
It
previously
generated
this
file
and
it's
important
to
know
that,
because
you
could
use
that
information
if
the
generator
knows
what
the
the
key
is,
that
decides
what
to
generate.
If
that
key
is
out
of
date,
that
is,
if
it's
older
than
the
generated
file
that
got
passed
in,
then
we
can
use
a
simple
like
time,
stamp
check
right
and
say.
E
E
E
C
A
Mean
that's
kind
of
the
same
thing
that
I
saw
with
assembly
info
dot
CS,
even
though
that
is
relatively
simple
in
the
old
world
like
it
was
a
pain
in
the
ass
to
actually
maintain
right,
especially
when
you
want
to
share
between
project.
It
became
really
hard
and
I
generated
files
of
basically
seeing
zero
issues
with
that,
because
is
always
up
to
date
and
never
gets
stale.
Another
question
that
comes
up
is
like
how
does
it
relates
to
F
sharp
type
providers
and
other
unifying
this?
We
they.
A
E
C
C
E
C
Already
a
sticking
point
and
then
also
the
generated
sources,
C
sharp.
We
ask
you
to
generate
a
string,
so
if
you
generate
a
C,
sharp
string,
the
F
sharp
compilers
not
gonna
like
that.
So
the
answer
is
like
source
generation
by
definition
is
a
bit.
You
know
it's
a
little
bit
specific
to
the
source
of
the
code,
you're
compiling
yeah,
so.
B
C
C
Even
yeah,
even
if
you
get
all
that
right,
even
if
all
you
need
to
do,
is
generate
code
not
dependent
on
the
user's
source.
Before
running
that's
hard,
when
you
need
to
depend
on
the
users
source,
then
it's
really
really
hard.
It's
basically
impossible
in
order
to
generate
a
compilation
that
reflects
how
the
compiler
is
actually
going
to
use
the
code,
it's
incredibly
difficult
and
if
the
probability
that
somebody
is
gonna
insert
some
property
in
between
when
you
run,
and
when
that
you
grab
the
compilers
inputs,
it's
really
high.
C
You're,
probably
gonna
get
wrong
options
or
something.
So
the
idea
was
the
compiler
already.
Has
the
right
compilation,
there's
no
other
compilation
that
it
could
possibly
have.
Why
can't
we
provide
some
mechanism
to
get
in
there
and
also
there's
just
like
well
what,
if
you're,
not
using
msbuild
right?
What,
if
you're
using
a
custom
built
you
can
be
using
make
and
that's
fine,
you
call
CSC
directly
fine.
C
It's
also
not
the
greatest
experience
in
some
ways
what
it
works
and
the
source
generation
would
work
the
same
regardless.
So
we
really
wanted
to
kind
of
provide
a
simpler
mechanism
to
get
rid
of
a
lot
of
that
boilerplate
as
well,
and
that's
that's
one
of
the
things
that
people
struggle
with
there
are
some
libraries
to
improve
that,
but
also
I,
gotta,
say
heroic
efforts
out
there,
people,
but
you
shouldn't
shouldn't,
have
to
do
that
right.
C
B
I'm
saying
yep:
okay,
hi
shot-out
thanks
this
is,
and
thanks
for
the
folks
that
brought
this
up.
We
are
weird
we
do
watch
what
goes
on
the
community
and
like
Annie
says
we
really
appreciate
it
when
people
step
out
ahead
of
us
and
Michael
I
hope
you'll,
give
us
some
feedback
on
what
we're
thinking
about
what
you
heard
today.
B
If
we
missed
a
comment
in
as
it
would
by
then
apologize
for
that
because
it
some
of
you
may
know,
I
have
been
in
the
space
forever
and
done
a
couple
things
myself
that
actually
didn't
turn
out
in
the
end
and
know
that
there's
some
really
big
challenges
along
the
lines.
I
attempted
once
to
use
Rosslyn
I
shout
out
somebody
who's
got
that
actually
working
well
and
oh.
B
C
B
A
long
way
with
because
when
I
was
working
on,
it
was
early
in
the
the
Ross
Rosen's
come
a
long
way
for
its
usability,
but
because
of
the
focus
on
making
the
analyzers
a
little
bit
more
more
a
little
bit
easier
to
write
that
they
were.
The
work
I
did
seven
eight
years
ago
was
using,
didn't
have
that
and
it
just
really
it
was
it
was.
B
D
B
The
fact
that
now
we
can
run
in
real
time
and
I
also
a
big
difference,
I
think,
is
that
in
2000
the
work
at
least
that
I
was
doing
done,
was
generating
massive
amounts
of
code.
An
application
might
be
10%
not
generated
90%
generated
massive,
massive
and
I
think
we
have
so
many
other
ways
now
to
cut
that
down
that
now,
I
do
think
that
it
will
be
uncommon.
In
fact,
I
actually
would
encourage
anyone
who's.
B
Looking
at
you
know
more
than
a
10
or
15
20
%
generation
and
application
to
at
least
take
a
second
look
at
it
to
see.
If
there's
other
ways
to
so
now,
the
amount
of
generation
we're
doing
is
more
doable
in
real
time,
which
I
think
is
fantastic,
actually
being
able
to
get
intellisense
on.
You
know
you
generate
a
code
as
you
type,
you
know
you
type
you
had
name
as
your
example.
Getting
that
I
don't
know.
C
Mean
it's
all
like
that's
that's
the
other
thing
before
there
were
so
many
open
questions.
We
couldn't
see
a
path
for
a
lot
of
these
things
now.
I
think
the
the
main
thing
that
so
Chris
has
been
Chris
from
the
compiler
team
he's
been
working
on
kind
of
fleshing
out
a
lot
of
the
original
ideas
and
actually
going
down
these
paths
and
making
sure
there
are
answers.
That's
the
that's
the
main
thing
that
was
necessary.
C
A
Think
that
I
mean
the
one
on
one
problem
that
we
face
on
our
side
is
that
you
know
I
work
in
the
corvex
team
and,
like
we
do
a
lot
of
in
a
performance
work
on
other
things
and
like
the
number
one
challenge
that
we
see
with,
like
you
know,
large
applications,
whether
the
internal
or
external,
is
that
almost
all
of
them
rely
to
a
somewhat
unhealthy
degree
on
reflection,
reflection
amid
and
I
think.
The
large
reason
for
that
is
that
design
time
code
generation
is
just
plain
sucks.
A
It's
hard
to
do
it's
it's
especially
hard
for
library,
authors,
because
you
don't
control
the
application.
You
don't
control
the
build
process
of
the
application,
so
plugging
your
code
in
at
the
right
time
in
msbuild
for
whatever
we
know
crazy
customers
build
process,
the
consumer
has
is
virtually
impossible,
and
so
that,
but
reflection
Amit
is
nice
because
you
do
it
at
runtime.
You
know
the
type
system
is
much
more
simple
at
one
time:
don't
you
worry
about
multiple
languages
or
msbuild
or
anything
like
that?
A
So
we
just
shipped
the
system
text
or
JSON
like
a
high-performance
JSON
stack
and
the
serializer
is
something
that
you
obviously
could
coach
n
right.
You
could
obviously
have
some
code
that
says,
given
a
writer,
you
know
I
just
read
and
write
the
properties.
You
know
one
by
one
and
the
code
is
pretty
simple
and
the
reflection
code
that
you
would
have
to
admit
at
one
time.
Is
it's
not
that
simple
and
like
that
could
significantly
improve
the
performance
of
the
of
this
utilizar?
A
But
the
challenge
here
again
is
like
how
do
you
make
it
composable
right
when
you
have
multiple
different
types
from
different
assemblies?
How
do
you
generate
a
thing
for
that?
It
might
in
all
cases
and
I,
think
that
will
be
one
of
the
challenges
you
have
to
figure
out
and
that's
why
I'm
very
interested
to
see
your
hobby
yeah
that.
C
C
Of
getting
reflection
out
of
the
way,
not
just
because
it's
expensive,
which
it
is
its
platform
dependent
which
is
yes,
but
because
it's
often
wrong.
The
code
that
I
want
to
write
is
against
the
types
that
I
see
as
the
developer,
not
whatever
happens
to
be
on
the
machine
at
runtime,
but
would
I
actually
see
and
I
know
that
there
uses
wiring,
where
you
actually
want
to
use
the
runtime
type.
But
that
wasn't
what
I
wanted
then,
so
that
this
is
like
a
completely
different
approach.
No.
A
It's
like
in
some
person,
comments
and
says,
like
it's
even
harder,
a
JVM.
Do
you
to
type
it
Roger,
but
even
internet
deck.
The
some
of
the
concepts
we
have
in
source
do
not
have
a
corresponding
il
issue
right,
I'll,
feature
I,
guess
so,
there's
already
some
cases
where,
depending
on
what
you
want
to
do,
it
might
be
significantly
harder
for
you
to
do.
If
you
can't.
Actually,
you
know
reason
about
types
in
the
in
the
context
of
of
c-sharp
stipes
right
and
I
feel
like.
C
C
C
A
B
I
just
add
that
I
think
we
have
some
good
some
good
answers
for
the
that
seperated
ahead
of
time.
You
know
you're
going
to
have
a
tool
that
does
that
sort
of
before
you
get
into
your
c-sharp
code
and
that
would
be
T
for
s1
and
I'm,
trying
to
think
of
the
liquid
liquid
coming
out
of
the
Ruby
space.
There's
some
others
out
there
I
think
we've
got
solutions
for
that.
Well,
we
don't
have
solutions
for
right
now.
B
B
C
The
idea
is,
we
have
a
flag
right
now
called
additional
files
and
it's
an
analyzers
just
pass
in
whatever
file
they
want,
and
the
idea
is
that
they
get
to
be
seen
by
the
analyzer
they're,
not
input
to
the
c-sharp
compilation,
but
the
analyzer
can
use
them.
However,
so
the
idea
is:
oh,
you
want
to
write
a
generation
for
gr,
PC
or
whatever
pass
in
your
dot,
protobuf
files
or
dot
proto
files
as
additional
files
and
then
spit
c-sharp
code
for
them,
but.
B
C
B
C
B
So
all
right
so
I'm
curious
about
that,
because
I
certainly
had
thought
about
this
in
the
limited
space
of
the
real
time:
compilation,
problems,
I'm,
sorry,
real
time
generation
problems
and
I
had
expected
that
protobuf
etc
would
stay
out
in
the
liquid
or
t4
space
and
you're.
Saying
no
I
would
do
that
too.
Why.
A
B
C
That's
the
problem
right.
So
if
you
can't
unload
the
assembly,
then
you
can't
actually
you
you
can't
rebuild
the
assembly
and
load
it
again
right.
You
would
have
to
shut
down
Visual
Studio
or
so
the
answer
is
probably.
These
are
technically
solvable
problems,
certainly
with
analyzers
I.
Think
some
of
them
got
less
focus
analyzer
assemblies,
you
they
load,
you
load
them
once
and
then
they're
loaded
forever,
but.
A
C
An
analyzer
hat,
so
what
happens?
Is
you
have
to
essentially
have
a
condition
upon
the
project
building
and
then
there's
an
analyzer
dll
that
gets
created
and
the
next
project,
the
one
that
consumes?
The
analyzer
needs
to
load
that
dll.
It's
not
a
project,
a
project,
reference
thing,
because
these
aren't
references
right
right.
C
C
B
C
Out
unloading
that
original
thing,
so
we,
the
answer,
is
I,
think
that
you
can
probably
do
some
stuff
like.
If
you
have
an
assembly
unload
with
assembly
live
context,
then
you
could
simply
unload
be
simply.
You
could
also
load
it
in
a
background
process
and
then
kill
the
process
like
that.
There
are
a
variety
of
different
technical
solutions
to
this
problem,
some
of
them
more
complicated
than
others.
If
it's
that
important
of
a
scenario
yeah,
we
could
solve
them
in.
B
C
C
C
Yeah
most
of
time,
you're
not
revving
the
analyzer
at
the
same
time,
like
it's
an
important
development
scenario,
exactly
if
you're
building
the
analyzer
but
then
the
answer
is
you
probably
don't
want
a
lot?
You
don't
necessarily
want
to
build
your
analyzer
against
your
real-world
solution.
Anyway,
you
want
to
build
it
against
unit
tests
because
it's
easier
to
get
feedback
and
stuff,
and
we
have
a
unit
test
framework
for
analyzers
built
in,
so
you
actually
would
prefer
to
kind
of
use.
C
The
unit
testings
well
I
would
prefer
that
you
use
the
unit
testing
scenario
to
narrow
in
on
the
behavior
of
your
analyzer,
ensure
that
it's
the
correct
behavior
in
a
variety
of
different
circumstances
that
are
not
necessarily
your
real-world
project
right
now
at
this
very
second
and
then
ship,
the
analyzer
appropriately.
Yes,.
B
So
if
you
have
a
scenario
where
you
think
the
generator
needs
to
be
in
the
solution
is
a
sort
of
a
core
part
of
the
of
the
user
story.
The
core
part
of
what
you're
trying
to
accomplish
be
really
good.
To
know
about
that,
so
that
we
can
kind
of
figure
out
what
priority.
To
put
on
this
notion
of
being
able
to
update
the
generator
in
closer
to
real-time
yeah
I
mean.
C
C
C
That's
that's
all
it
is.
You
don't
necessarily
need
to
ship
everything
as
a
NuGet
package,
but
you
can
just
phase
the
build
such
that
and
yeah.
During
the
development
time
period
it
can
be
expensive
to
change
the
generator
because
you
have
to
close
Visual
Studio
studio
and
reopen
it
right,
and
so
that's
the
kind.
That's
the
thing
that
we
wouldn't
improve
upon
that
when
you're
developing
the
generator
and
running
it
against
real
world
apps.
That
might
be
something
that
could
use
improvement
so.
B
C
Computer
stem
forward
to
the
the
entire.
The
reason
that
everything
would
be
loaded
is
that
it's
faster,
like
it's
just
a
performance,
optimization.
The
thing
that
you
can't
do
today
is
load
the
Roslin
solution
like
this
and
then
also
use
the
stack
compilation
in
the
same
process
for
for
the
actual
compilation.
C
So
anybody
who's
doing
this
today,
loads,
Roslin
and
all
of
the
files
and
then
kind
of
does
whatever
generation
they
want
to
do
and
then
calls
the
compiler
right
so
you've
loaded
all
of
the
stuff
for
rot
for
the
actual
compilation
and
then
added
more
stuff,
and
then
the
Rosalind
compiler
will
go
and
load
all
of
the
same
stuff
again
and
then
load
your
new
stuff.
So,
in
addition
to
all
of
the
process
overhead,
the
jitang
the.net
start
like
process
startup,
like
all
of
that,
plus
all
of
the
extra
file.
Io
extra
analysis.
C
B
C
C
B
B
You
know
it
doesn't
hurt
to.
Let
us
know
if
you
think
it's
important
doesn't
hurt
to
you
know,
reach
out.
You
know
on
the
document
on
the
design
document,
if,
if
you
say
really
really
want
this
as
well
as
telling
us
what
you
what
you'd
like
and
don't
like
it
about
it
that
that
never
hurts
but
it'll
be
prioritized
along
with
some
other
important
things
we're
talking
about
including
records,
including
you
know,
some
other
smaller
features
and
I,
don't
even
know
what
else
we
have
on
the
table
right
now,
I've
missed
so
many
meetings.
It's.
C
M,
but
that
it's
more
about
like
yeah
the
documents
figuring
out
exactly
what
what
we
want
to
build,
how
we're
gonna
build
it,
how
we're
gonna
address
those
scenarios
that
I
talked
about
at
the
beginning
of?
When?
Can
you
not
run
a
generator
like
really?
That's
that's
the
thing
that
got
us
stuck
last
time
and
we
think
we
have
answers
to
that
now
with.
Oh,
you
can
kind
of
have
a
progressive
enhancement
story
for
an
analyzer
where
you
have
you
set
certain
triggers
saying.
My
generator
only
depends
on
say
this
dot
profile.
B
C
C
B
A
Good
so,
like
I
mean
yeah,
like
the
only
call
to
action
that
I
think
I
have
for
the
rest
of
you
download,
dotnet
core
3.1
flavored,
give
us
feedback
stay
tuned,
that
we
will
share
more
links
to
documents
that
you
can
read
like
it's
always
hard
to
understand
the
design,
but
just
watching
three
people
chatting
about
it,
it's
always
easier
to
actually
have
bits,
or
at
least
a
design
document,
and
they
will
also
come
I.
Think
as
we
are
starting
to
plan
more
for
five
or
the
ideas.
C
Thing
we're
working
on
now
for
source
generators
is
kind
of
a
series
of
design
patterns,
ways.
We
think
that
you'll
be
able
to
kind
of
examples
of
stuff
like
I
notify
property
changed
like
do
you
want
to
generate
I,
know
notify
property
change
here.
Just
here's
a
design
pattern
that
you
could
use
and
kind
of
you
use
that
to
make
your
own
stuff
is.
B
B
C
A
C
C
B
B
B
B
So
thanks
for
sticking
with
us
folks,
we
talked
away
too
long
today.
We
have
done
this
before
by
we're
in
an
hour
and
a
half
right
now
for
an
hour,
long
community
stand
up
and
I
think
it's
time
from
all
our
sakes
for
us
to
call
it
a
day
and
get
on
with
with
what
else
you
all
are
doing
today
and
thanks
again,
meetings
mango.