►
Description
Join @KathleenDollard @_cartermp and @terrajobst for the .NET Languages & Runtime Community Standup. Today, we'll talk about source generators!
Featuring: Kathleen Dollard (@KathleenDollard), Phillip Carter (@_cartermp), Immo Landwerth (@terrajobst )
#CSharp #SourceGenerators #dotnet
A
A
A
Hello
friends,
presumably
we
are
now
live
again
today.
Our
topic
is
going
to
be
source
generators
and
I
will
not
talk
much.
Hopefully,
I
will
just
ask
questions
and
then
we'll
see
how
that
goes.
So,
let's
introduce
ourselves
again.
So
my
name
is
emily
enrouth,
I'm
a
programmer
and
program
manager
on
the
dotnet
platform
team
and
with
me
today
are.
C
A
B
Oh
yeah,
we
got
a
couple
of
things.
We
look
at
a
little
bit
of
code,
we're
going
to
talk
about
source
generators.
We
search
generators
are
super
interesting
and
we'll
talk
about
how
you
might
use
them.
How
they're
going
to
affect
you?
Even
if
you're,
not
writing
them
yourself
and
show
you
some
generators
that
are
simple
and
one
generator
that's
kind
of
complicated
and
talk
about
how
to
think
about
the
problem.
So
yeah,
that's
the
story.
We
might
talk
about
other
things.
B
B
A
B
B
B
A
B
C
Source
generators,
you
know,
as
you
mentioned,
the
sort
of
first
release
came
out
this
april.
It
was
very
just
preliminary
release
and
it
sort
of
addressed
kind
of
some
just
kind
of
laying
the
groundwork
for
this.
This
compiler
feature
so
kind
of
at
a
high
level
most
of
the
times
when
we
do
new
features
in
c
sharp.
They
are
language,
features
like
records
or
better
pattern
matching
or
something
like
that.
But
source
generators
are
a
compiler.
A
C
And
not
a
language
feature,
so
I
mean
what
we
do.
Is
we
still
right
now
it
kind
of
require.
I
think
we
shouldn't
require
this
anymore,
but
we
did
at
one
point.
We
required
you
to
set
your
language
into
preview
because
we
reserved
the
right
to
make
breaking
changes
and
source
generators
as
they
were
being
built,
but
source
generators
are
fundamentally
a
compiler
feature,
they're,
basically
they're
kind
of
like
analyzers,
but
they
allow
you
to
also
emit
c
sharp
source
code
sort
of
when
the
analyzer
is
finished
running.
C
So
if
you're
familiar
with
analyze,
basically
run
during
compilation
and
they
analyze
your
source
code
and
they
emit
diagnostics.
So
an
analyzer
will
say:
oh
well,
you
know,
I
know
that,
like
I
don't
know
like
there's.
No,
maybe
a
good
example
is
there's
there's
like
no
no
return
value
emitted.
You
know
from
like
a
method
or
something
like
that,
or
maybe
there's
a
cut,
there's
and
there's
a
bunch
of
other
custom
analyzers
that
are
written
like
xunit
has
a
couple
of
them
where
it's
like.
C
Oh
hey,
you're
doing
this
thing
with
the
api
and
that's
not
really
a
good
idea.
You
should
actually
use
this
api
instead
and
we're
also
releasing
a
lot
of
images
in
dom
at
5
that
are
along
those
lines
of
helping
you
better
use,
net
apis
and
they're
all
about
introspecting
code.
But,
as
I
said,
all
they
can
do
is
emit
a
diagnostic.
They
can
tell
you
that
you
did
something
wrong
and
where
that
some,
where
you
did
something
wrong
or
something
wrong,
could
also
just
mean
hey.
C
You
could
improve
this
area
and
the
code,
and
maybe
that
could
you
know
affect
a
code
fix
that
could
adjust
the
code
and
things
like
that,
but
they
don't
emit
source
code.
They
emit
diagnostics.
So
so
search
generators
come
in
and
they
say
well,
sometimes
you
don't
want
to
emit
a
diagnostic.
Sometimes
you
want
to
analyze
source
code
and
you
want
to
generate
source
code
from
the
code
that
you've
been
analyzing.
C
It's
a
meta
programming
feature.
Basically,
there
are
a
lot
of
other
meta
programming
features
out
there
that
exist
in
other
languages
that
kind
of
act
in
a
similar
space.
Some
people
have
certainly
mentioned
that
in
the
initial
blog
post
that
you
know,
macros
are
a
similar
sort
of
feature
in
other
languages.
C
Where
you
can,
you
can
write
code
that
generates
code,
basically
based
off
of
the
structure
of
the
code,
that's
being
analyzed
source
generators,
work
and
a
little
bit
differently,
but
fundamentally
they
are
an
analyzer
that
analyzes
your
source
code
and
then
there's
a
small
set
of
apis
that
you
use
to
generate
c
sharp
code
based
off
of
what
you're
reading.
Now,
it's
not
just
source
code
that
acts
as
an
input
to
a
source
generator.
Now,
when
I
first
wrote
this
blog
post,
that
was
actually
all
that
you
could
do
all
I
could.
C
In
addition
to
some
tweaks
to
the
api
and
stuff
like
that,
so
now,
there's
sort
of
two
key
capabilities
in
addition
to
apis
and
better
visual
studio
tooling,
is
that
you
can,
as
a
part
of
sort
of
you,
know,
the
host
that
hosts
the
source
generator
in
compilation
can
say.
Here's
additional
data
that
I'm
gonna
pass
down
into
the
source
generator
and
the
source
generator
can
say.
I
accept
data
that
looks
like
this
source.
C
Generator
itself
can
now
depend
on
a
package,
and
it
can
use
these
two
things
input
from
the
program
and
a
package
that
it
depends
on
to
generate
a
much
more
interesting
code.
So,
in
this
updated
blog
post,
it's
called
new
c-sharp
search
generator
samples.
There
are
two
of
them
I'll
talk
about
the
first
one
briefly,
which
is
being
able
to
give
you
strongly
typed
access
to
a
csv
file.
B
D
C
Yeah
and
so
at
a
high
level,
what
this
one
generator
does
is
it
accepts
input
from
from
the
host
program,
because
this
is
csv
file.
I
want
you
to
generate
c
sharp
code,
that
maps
to
that
to
that
csv.
So,
like
the
rows
and
the
columns
like
all
the
names
and
stuff
can
be
accessed
in
my
calling
c
sharp
code,
so
basically
it
will
be
passed
a
csv
file.
It
will
read
that
csv
file.
C
It
will
then
break
classes
that
map
to
sort
of
the
structure
that
csv
file
and
those
classes
will
be
emitted
as
source
code
that
that
a
calling
program
now
has
access
to.
So,
instead
of
you
having
to
write
a
you
know
your
own
csv,
parser
and,
and
that
kind
of
stuff
you
can
just
say,
oh,
give
me
the
strongly
typed
class
that
represents
this
csv
file
and
then
I'm
just
going
to
dot
into
you,
know,
rows
and
columns
and
that
kind
of
stuff
and
get
the
data
that
I
need.
C
So
this
is
something
that
kathleen
is
going
to
dive
quite
deep
into
and,
I
believe
kathleen.
You
would
mention
that
you
have
some
tips
and
tricks.
So
not
just
showing
the
code
but
showing
how
you
can
do
some
really
cool
stuff
when
you're
working
on
source
generators.
So
I'm
pretty
excited
to
see
what
you
have
to
show
us.
A
A
B
Compiler,
that's
working
with
right,
so
one
of
the
common
things
it
can
do
is
if
you
want
to
put
a
logging
message
at
the
top
of
every
method.
That
is
a
that
is
something
you
can
do
with
foti
but
you're.
This
is
not
something
you're
gonna
do
with
the
c-sharp
source
generators.
That's
it's
just
not
designed
for
that.
So
I
don't
think
it
takes
post
shark
and
photo
out
of
the
picture
completely.
B
So,
let's
look
at
some
code:
we've
gone
too
long
without
looking
at
code,
so
let
me
bring
up
source
generators
and
there
was
a
link
in
the
blog
post.
You
just
looked
at
that
would
take
you
to
a
repo.
It
is
the
rosalind
sdk
and
I
cloned
the
roswell
sdk
and
then
wandering
down
in
there
under
samples.
I
found
the
source
generator
samples
and
opened
the
solution
that
was
there.
That's
how
I
arrived
at
the
code
we're
looking
at
today.
The
first
thing
I
want
to
look
at
is
actually
the
hello
world
generator.
A
B
I
think
that's
great
okay,
so
this
is
a
source
generator
and
we'll
come
back
to
to
look
at
this,
but
we
also
want
to
look
at
how
it's
called
so.
Those
two
things
go
hand
in
hand.
So
the
code
you
would
write
is
this.
This
is
all
the
code
that
you
write
in
this,
but
you
have
a
you:
have
a
reference
to
a
package
and
a
package.
Reference
is
to
this
hello
world
nup
keg.
B
B
We
could
pick
something
up
from
this
and
try
to
search
the
project
and
you
wouldn't
find
it
because
this
is
in
a
temporary
location,
but
the
code
is
available
to
you
and
you
can
ask
that
it
be
written
out.
If
you
want
to
have
a
record
of
that,
I
don't
know
other
than
just
an
occasional
check
when
you
would
want
to
do
that
now.
This
is
hello
world
and
you
can
obviously
write
a
library
that
had
the
first
two
lines
line,
9
and
10,
but
lines
11
through
18
are
specific
to
this
project.
B
B
So
this
is
kind
of
the
simplest
one
and
I
think
it
shows
us
how
to
the
generator
works.
If
you
want
to
write
one
and
understanding
how
it
works
is
fun,
even
if
you
don't
know
if
you're
right
one.
So
there
are
two
there's
actually
three
methods
that
you
might
be
interested
in,
one
of
them
is
an
initialize.
So
if
there's
something
you
need
to
do
to
start
up,
then
you
can
do
that.
B
So
here
we've
got
this
hello
world,
that's
great
and
then
it
goes
through
and
it
looks
at
the
syntax
trees
just
as
a
way
to
mark
that
it
is
not
the
same
as
having
a
library
all
right.
So
do
we
have
any
questions
in
chat
on
this
much
because
I'm
about
to
jump
into
that
csv
generator
that
philip
just
talked
about.
B
A
B
B
I
can't
imagine
how
it
cannot
be
embedded,
so
it
is
source
code
once
it's
created,
so
the
compiler
has
a
step
like
it
does
with
analyzers
and
other
things
and
says.
Oh,
let
me
see
if
there's
something
else
to
do.
Oh,
I
need
to
run
some
source
generators.
Let
me
run
those
source
generators
and
now
it's
code,
there's
nothing
different
between
this
code
and
the
rest
of
the
code.
So
it's
it's
not
in
my
mind,
right
now,
anyway,
this
could
not
be
in
the
pdb.
B
B
It
is
part
of
net
five,
it's
part
of
c
sharp,
the
c
sharp,
nine
compiler
and
what
I
don't
know,
but
philip
my
is
do
we
is.
Can
you
use
this
on
lower
versions
of
c
sharp
if
you're
in
the
c,
sharp
nine
compiler,
it
is
a,
it
is
compiler
features.
So
I
don't
know
what
we've
done
with
that.
If
we
believe
there
was
problems,
we
would
have
blocked
it,
we
would
have
blocked
it
if
we
thought
you
could
get.
D
D
C
B
So
the
one
that's
in
preview
right
now
is
where
you
see
this,
I
am
running
the
public
preview,
so
everything
I
do
today
you
can
do.
It
was
a
little
more
stable
than
the
nightly
I've
been
having
trouble
with
the
nightly.
So
I
I
jumped
into
the
most
recent.
I
don't
know
what
it
is.
I'd
have
to
look
to
see
what
the
version
is.
Any
other
questions
are,
we
are
we
people.
B
Yeah
so
mark
mark
flux
said
that
the
the
the
challenge
is
in
understanding
the
syntax
tree
and
that's
why
I'm
going
to
talk
about
separating
the
process?
That's
where
the
real
work
is
creating
strings,
that's
for
using,
but
getting
figuring
out
what
you
have
to
start
with.
That
can
be
hard
and
I'll
talk
a
little
bit
about
it
in
two
contexts
here
in
a
minute
all
right.
So
let's
look
at
that:
csv
generator.
Okay.
B
So,
first
of
all,
let's
look
and
see
what
here's
the
csv
cars
don't
csv,
there's
just
some
cars,
okay
and
second
of
all,
we're
going
to
go
to
the
used
csv
generator
to
see
what
the
code
looks
like.
Okay,
so
we
have
a
cars.
We
have.
A
cars
class
obviously
has
a
static
method.
We
look
at
this
as
c-sharp
programmers
and
we
go
hey.
There's
a
standard
method
called
all
and
let's,
let's
look
for
this:
let's
go
ahead
and
do
the
search
for
cards
across
this
entire
solution
and
see
what
we
find.
B
B
I
guess
it's
the
size
of
the
engine,
and
then
we
have
two
entries
that
are
the
all
that
are
going
to
be
there.
Where
did
this
come
from?
How
did
it
get
that
data?
Where
did
where
did
it
come
from?
And
that
is
what
is
different?
There's
two
things
diff
special
about
this
one
is
that
the
csv
doesn't
necessarily
have
this
shape.
Sure
we
could
put
this
shape
into
a
nuget
package
if
we
already
knew
what
cars
looked
like,
but
we
don't
know
what
cars
looks
like.
B
We
don't
even
know
that
it
was
going
to
be
called
cars
okay,
so
all
of
this
is
generated
based
on
the
csv
and
so
what's
a
code.
That's
is
that
heart.
Is
that
code
hard?
So
let's
take
a
look
at
that
and
well
I'm
not
there,
sorry,
the
one
above
it
there.
We
go
all
right.
So
this
one
has
a
lot
of
has
a
lot
of
methods
in
here.
Most
of
these
are
public
and
don't
need
to
be.
B
I
would
suggest
that
you
consider
bringing
these
outside
of
the
actual
this
actual
file
into
something
that
you
can
actually
work
with
and
test
a
little
bit
more
removed.
The
fact
they're
public
doesn't
mean
they
are
testable,
but
there's
other.
You
also
don't
need
to
necessarily
put
all
this
into
this
file.
You
just
need
to
run
it
like
normal
c
sharp
code.
This
is
just
normal
c,
sharp
code
doing
normal
c
like
things.
B
What
we
want
to
look
at
for
is
the
execute
method,
so
we
have
execute
initialize
and
one
more
that
we'll
look
at
in
the
final
generator.
That's
in
those
samples
that
we're
going
to
look
at
all
right.
Any
questions,
emo
and
and
philip,
if
you
want
to
stop
me
when
we
have
something
we
need
to
look
at
in
terms
of
questions,
we
need
to.
B
B
However,
we
are
planning
on
enhancing
the
vp
experience
and
I
do
understand
how
confusing
that
is
right
now
and
I'm
hoping
once
68
hits
the
street
and
people
see
what
that
actually
means
that
there's
going
to
be
less
confusion,
but
we
are
discussing
that
right
now
and
then
f
sharp
uses
a
different
compiler
so
that
if
they
were
to
support
this
philip
can
comment
on
this.
It'd
be
a
lot
of
work.
B
C
There's
no
there's
no
plan
to
ever
support
this.
On
the
f
sharp
side,
there
is
a
eventual
desire
to
do
code
generation
for,
for
you
know,
helping
aot
scenarios,
but
it's
not
like
source
generators
itself,
like
there's
no
plan
at
all.
To
do
that,
it
would
require
rewriting
the
entire
f
sharp
compiler,
which
we're
not
going
to
do
all
right.
So.
A
B
They
have
to
be
written
in
a
way
that
they
can
run
in
any
order.
It
cannot
depend
on
each
other,
and
that
is
also
kind
of
unlikely
to
change.
We
do
know
that
for
some
people
it
means
they
have
to
think
about
some
things
differently.
Specifically,
if
two
can
go
into
the
same
nuget
package,
then
you
can
kind
of
see
how
they
can
submission
and
use
code
use
the
information
from
each
other
that
doesn't
rely
on
the
order
in
which
they
occur.
B
For
example,
you
might
have
two
and
some
sort
of
a
configuration
to
say
whether
they
should
both
run
and
then
they
share
data
and
whichever
one
runs
first
sets
that
data
up
there's
some
things
like
that
you
can
do,
but
in
terms
of
actually
saying
that
we're
going
to
have
them,
ordered
that's
highly
unlikely
to
happen.
So
what
I'm
anything
else
you
know,
I'm
sorry.
I
want
to
jump
on
too
quick.
B
And
I'm
not
saying
that
right
now,
let's
go
to
get
load
options
and
see.
If
that
shows
us
opening
an
external
file
point
is
that
there's
things
called
additional
files
that
are
generally
going
to
be
set
in
your
in
your
project
file,
so
here's
additional
files
for
people
and
cars,
so
we
can
open
these
additional
ones.
There's
also
some
just
general
settings,
that's
desired
by
this
generator,
so
it's
opening
an
additional
file
and
that's
the
the
way
that
you
do
that.
B
So
that
means
that
the
cars.csv,
the
fact
that
class
is
named
cars.
The
fact
that
that's
the
csv
file
that
you
open
that's
defined
in
your
project
file,
so
generate
a
demo.
That's
your
code
and
then
the
generator
can
pick
that
up
and
has
the
capacity
to
use
these
external
files
for
configuration
in
the
generator
or
any
other
purpose
like
this
csv.
B
So
we
can
do
additional
files,
we
can
do
we
can
initialize,
then
I'll,
show
you
in
a
minute
how
we
can
pick
up
data
more
easily
than
having
to
go
through
the
entire
syntax
tree.
That
is
the
hard
part
of
this
and
for
simple
analyzers.
There
is
a
shortcut
you
can
take
that
will
probably
be
pretty
effective.
B
C
B
Am
going
to
talk
about
unit
testing
because
I
did
all
of
my
work
with
the
intention
of
oh,
my
gosh,
especially
because
I
have
right
now,
just
one
contributor,
when
I
show
you,
I
want
more
contributors,
so
when
I
get
there
pay
attention
and
see
if
you
want
to
help,
but
the
contributor
I
have
is
hardcore,
tdd
relatively
early
career
never
worked
without
tdd,
and
so
it's
like
this
has
to
happen
this
way.
So
I
will
yeah
we
will.
B
I
will
show
you
about
testing,
because
yes,
testing
could
be
a
nightmare
and
it
it
takes
some
work
to
have
it
not
be
a
nightmare,
and
I'm
really
pleased
with
where,
where
I'm
at
with
that
so
anyway,
let's
look
quickly
at
auto
notify
generator
for
one
thing
in
here:
I'm
not
going
to
go
through
this
whole
generator,
I'm
in
the
wrong
place.
I
want
to
be
in
the
generator
itself,
which
is
right
here.
Oh
before
I
go
there,
I
talked
to
you
about
the
fact.
B
We
can't
change
existing
code,
and
so
sometimes
we
might
have
to
be
a
little
tricky,
and
this
is
a
little
tricky,
so
notify
property
change.
If
you're,
not
if
you're
a
web
programmer,
you
may
not
know
about
this,
which
is
things
that
work
on
events
which
are
all
the
desktop
stuff.
Anything
like
that,
I
often
have.
I
want
to
be
able
to
say
for
this
class.
I
want
you
to
raise
an
event
if
a
value
changes,
so
this
allows
a
field
to
be
updated.
B
That's
the
basic
problem,
we're
trying
to
solve
here
and
there's
a
long-standing
way
to
do
this
with
a
interface
called.
I
notify
property
change,
you'll
notice,
it's
not
on
this
class,
but
there
is
a
attribute
on
two
fields
and
the
reason
fields
are
used
is
because
we
can't
change
something
to
add
behavior
to
it,
but
we
need
some
special
behavior
on
the
property.
So
for
this
one
I
think
this
one.
B
Oh
boy,
I
don't
remember
how
today
to
get
to
a
class
that
you
can't
just
f12
to-
and
I
don't
think
I
can't
have
12
to
this
because
I'm
looking
for
the
other
partial.
These
are
partial
classes,
and
I
don't
actually
know
how
to
get
there
at
the
moment.
So
we're
not
going
to
look
at
the
output
code
right
now,
but
I
would
do
want
to
show
you
something
about
this
generator,
and
so
this
generator
is
looking
for.
It
is.
What
I
want
to
see
is
the.
B
Yeah,
okay:
this
has
a
syntax
receiver
and
the
syntax
receiver
is
registered
someplace,
let's
see
where
that
is
registered,
is
registered
right
here.
So
what
we're
going
to
say
is
we'll
say
that
a
syntax
receiver
is
a
way
that
you
can,
as
roswell
is
doing
its
work
as
the
compiler
is
working
it's
going
to
check
in
with
the
syntax
receiver
and
do
the
work
that
syntax
receiver
is
asking
it
to
do.
B
What
we
want
to
do
is
set
up
the
candidate
fields
ahead
of
time,
so
the
syntax
receiver,
which
is
registered
there,
is
going
to
run,
and
it
has
this
on
visit
syntax
note.
So
at
some
point
and
we
don't
care
when
rosalind
as
it's
doing
its
work
is
going
to
say,
I'm
going
to
pay
attention
to
this
syntax
receiver
and
I'm
going
to
call
that
code
and
do
whatever
it
tells
me
to
do
and
right
now.
B
What
it's
saying
is
that
you
know
what,
if
you're
a
field-
and
you
have
an
attribute
we'll
look
at
you
later-
you're
a
candidate-
we're
not
going
to
worry,
not
to
take
the
time
as
during
normal
compilation.
To
do
anything.
That's
not
super
fast
right
here,
but
finding
out
if
it's
a
field
and
if
it
has
an
attribute
super
fast,
so
we
can
pre-create
a
bunch
of
candidate
fields.
Now
the
person
who's
talked
about
how
difficult
it
was
it
is
to
work
with
a
syntax
tree.
This
is
a
shortcut
that
will
work
in
many
cases.
B
So
if
you
just
care
about
fields
now,
you
don't
have
to
worry
about
the
rest
of
the
syntax
tree.
All
you
have
to
worry
about
is
get
ahold
of
the
field
you
want
and
then
you
will
have
to
from
the
field
reach
back
up
to
grab
the
containing
class,
so
you
can
add
properties
to
the
containing
class,
but
that's
a
simple
jump
inside
the
syntax
tree.
B
Good
all
right,
so
I
want
to
just
talk
for
I
I'm
sorry.
I
almost
want
to
apologize
whenever
I
have
a
a
powerpoint,
but
I'm
a
pm
and
pms
do
powerpoints,
and
mostly
I
do
bad
powerpoints
these
days
and
this
powerpoint
man.
It
really
went
south,
but
it's
it's.
I've
got
enough
you're
going
to
be
able
to
see
it,
but
the
boxes
exploded
and
stuff.
It
really
got
ugly,
so
powerpoint
now
we're
not
getting
along
this
morning.
B
I
just
want
to
tell
you
what
this
project
does
so
there's
something
called
system
command
line
that
we're
working
on
as
a
parser
and
it's
available
for
global
tools.
Right
now,
lots
of
global
tools
have
used
it,
but
it
takes.
You
have
to
get
to
know
it.
It's
a
library
that
you
actually
have
to
learn
how
to
work
with,
and
my
goal
is
that
you
don't
know
anything
about
system
command
line
to
create
a
global
tool.
That
is
what
I
care
about
and
to
create
anything
else
that
needs
a
parser
command
line
parser.
B
So
that's
the
goal
that
I
want
to
get
to,
and
I
want
to
do
that
using
source
generators.
I
have
a
previous
version,
which
was
predictably
star
fruit,
1,
which
is
completely
based
on
reflection,
and
I
will
probably
completely
give
it
up
completely,
because
I
think
that
the
source
generation
is
that
much
better
of
an
approach
to
use,
so
that's
kind
of
a
little
bit
of
the
context
of
it.
B
What
I
want
to
focus
on
today
is
the
way
I
thought
about
the
complex
problem,
and
why
and
testing,
because
testing
is
a
big
deal
for
these.
You
can
just
imagine
if
you
get
something
complicated
how
quickly
it
could
just
be
crazy
to
try
to
test
it
so
rather
than
just
jumping
straight
into
tests.
I
want
to
show
you
the
way
I
thought
about
the
problem
in
order
to
make
it
testable,
so
that
is
looking
at
the
pipeline
from.
B
I
have
some
input,
which
is
going
to
be
c
sharp
code
right
now
and
then
I'm
going
to
get
to
actual
source
generator
in
the
end,
that's
the
pipeline.
I
want
to
work
on.
If
I
try
to
do
that
entire
pipeline
together,
then
the
person
who
said
this
is
going
to
really
be
hard
to
unit
test
is
absolutely
right.
How
do
you
do
that?
Well,
you,
don't
you
separate
it,
you
break
it
down,
that's
the
way.
B
We
know
to
get
to
a
testable
scenario,
so
we're
going
to
take
the
input
and
we're
going
to
go
through
something
I
call
it
a
maker,
but
whatever
we
go
through
something,
it
creates
an
interim
structure,
and
I
believe
this
is
very
important
to
do
for
non-trivial
source
generators.
Anything
where
you
can't
just
make
a
syntax
receiver
and
take
advantage
of
that
or
it's
not
super
easy
to
go
through
and
find
what
you
need
out
of
the
syntax
tree.
B
So
if
you're,
using
as
some
external
file
like
that
csv
file,
sure
you
know
you
can
just
put
it
in
place
and
test
it
and
that's
all
fine,
but
if
you're
actually
trying
to
reverse
syntax
and
understand
that
and
you
you
need
to
put
it
into
something,
you
can
look
at
and
test.
So
I
have
an
interim
structure
and
it
actually
models
what
I'm
going
to
output
and
creating
that
is
the
hardest
part.
By
far
of
this
exercise,
this
entire
problem
will
be
mostly
there.
B
B
So
then
there's
a
string
generator
that
creates
string
output
and
that
string
output
looks
like
c
sharp
code.
That's
what
it
actually
is,
but
we
want
it.
I
want
to
test
that
into
and
then
eventually
that
goes
to
the
source.
Okay,
so
eventually
it
winds
up
in
that
code
that
we
looked
at
with
the
samples-
and
I
probably
because
it's
the
way
I
tend
to
work-
will
have
separate
files
for
these
other
things,
but
they
all
get
combined
into
one
nuget
package,
so
the
string
output.
B
I
want
to
test
in
two
ways,
one
of
which
is.
I
want
to
oops.
First
we'll
look
at
the
whole
test
pattern,
so
I
need
to
give
it
the
same
thing.
The
source
generator
is
going
to
get
it,
so
I
need
to
start
with
something
I
think
I'm
actually
starting
with
a
syntax
tree.
Instead
of
the
full
generation
execution
context,
but
what
I
care
about
from
the
generation
execution
context
which
is
passed
to
the
execute
method
of
the
source
generator.
B
What
I
care
about
at
that
point
is
the
syntax
string,
okay
and
the
semantic
model
so
being
able
to
get
the
semantic
model
with
the
syntax
tree
and
the
context.
That's
what
I
care
about
and
then
I
also
may
care
about
candidates.
So
I'm
not
actually
using
a
I'm,
not
actually
using
a
syntax
receiver,
but
if
you're
using
a
syntax
receiver,
then
you
want
to
have
as
feed
into
your
process
a
set
of
candidates
which
you
can
just
manually
create
all
right.
B
So
the
next
thing
I
want
to
do
is
see
if
my
structure
interim
structure
is
right.
If
the
interim
structure
is
right,
I
want
to
test
the
string
output
in
two
ways.
The
first
thing
I
want
to
do
is
I
want
to
test
fragments.
This
is
where
our
unit
test
ideas
really
make
sense.
Okay,
I'm
not
going
to
say
tell
me
what
the
file
is
going
to
look
like.
I'm
going
to
say.
B
Tell
me
what
the
part
of
that
file
that
creates
a
command
a
system
command
line
has
creates
commands,
creates
options
so
a
part
that
creates
a
command
the
part
that
creates
an
option.
What
does
these
individual
small
pieces
look
like
and
that's
what
I
want
to
test
to
make
sure
they're
right
in
isolation,
and
then
I
have
more
tests
say
well,
if
I
wrap
that
in
a
class,
if
I
wrap
that
in
a
name
space,
how
do
those
things
start?
Do
those
things
look
correct
as
well?
B
So,
for
example,
I
might
have
a
very
complicated
option
and
be
checking
an
option
that
has
lots
of
different
things
set
on
it
to
see
whether
the
small
option
looks
correct,
but
then,
if
I
see
whether
it's
going
to
come
together
correctly
in
a
class,
it's
going
to
be
a
super
simple
option.
That's
fitting
in
to
see
whether
the
overall
class
looks
right.
Okay.
The
second
thing
I
want
to
do,
which
requires
really
fun
trick-
is
that
I
actually
want
to
run
that
code.
I
don't
want
to
wait
until
it's
sitting
in
a
source
generator.
B
First
of
all,
I
don't
want
to
wait
till
it's
sitting
in
a
source
generator
to
find
it
doesn't
compile.
Oh,
how
sad
will
that
be
and
remember?
This
is
not
a
simple
one,
so
we're
going
to
have
either
an
unbounded
list.
I
have
a
son
who's,
a
physicist,
so
it's
very
hard
for
me
to
say
it's
infinite,
because
he
would
he
would
complain,
but
it's
a
very
large,
very
set
of
variations.
B
That
could
happen,
and
so
many
things
could
fail
compilation
and
I
don't
want
to
find
that
out
after
I've
got
a
nuget
package,
that's
installed
in
a
project
somewhere
else.
I
want
to
find
that
out
in
a
test
compilation,
so
will
it
compile
and
then
once
it
compiles?
Actually,
I
want
to
run
it
and
I
want
to
see
if
the
output,
if
what
it
the
way
it
runs,
runs
the
way
I
need
it
to
run.
Okay.
B
B
I
know
this
is
a
lot
to
hold
in
your
head
for
just
a
second.
I
have
one
more
really
quick
thing
to
show,
which
is
for
us
there's
another
wrinkle
to
this
story,
which
is
that
the
input
may
not
just
be
a
c
sharp
model
on
the
c
sharp
model
we
would
bring
in
as
a
syntax
tree
which
we
can
create
and
go
from
there.
The
other
things
maybe
for
us,
is
a
json
file.
B
So
if
you
have
ever
typed
net
new
blah,
then
after
block,
when
you
add
net
new
blah
dash
dash
framework
okay.
So
when
you
say
that
framework
is
picked
up
as
part
of
a
parser
which
is
currently
the
old
old
old
parser
from
the
cli,
and
we
will
be
replacing
that
with
this
parser,
the
system
command
line.
Parser,
not
you
know
we're
using
this
over
the
system
command
line
parser.
So
we
can
get
to
that
power
in
in
amazingness.
B
This
is
just
like
how
we
get
there,
but
we
need
to
put
an
a
json
file
in
that's
what
we
have
from
the
template,
jason
that
we
start
with
and
then
once
we
get
this
in,
I
have
to
tell
you
I'm
very
excited:
we're
gonna,
have
tab,
completion,
soon-ish
on
on.net,
new
and
then
dotnet
new
template
name
and
then
have
tab
completion.
I'm
really
excited
about
that.
Okay.
So
that's
a
big!
That's
the
big
picture.
B
What
we're
doing
what
I
want
to
do
is
take
a
look
at
the
the
place
in
this
that
I
wanted
to
kind
of
drill
down
into
is
the
tests
and
the
tests
that
I
most
want
to
drill
down
into?
Are
the
two
around
the
strings?
So
can
I
compile
it,
and
can
I
run
it
now?
I
can
also
back
up-
and
I
can
show
you
what
our
input
is.
B
I
can
show
you
a
little
bit
more
about
the
generator
a
little
bit
more
about
what
the
interim
structure
looks
like
and
all
of
that,
but
I
probably
just
have
about
15
more
minutes
or
less.
You
guys
may
be
tired
of
hearing
from
me,
and
so
I
I
don't
want
to
get
too
scattered
across
this.
I
want
to
go
into
a
deep
understanding
and
I
think
this
is
the
most
interesting
part,
but
people
have
other
questions,
but
does
it
work?
Yes,
it
works
jason.
Yes,
it
it.
B
It
depends
on
how
you
define
working.
The
whole
thing
is
not
finished,
like
I
said,
definitely
open
to
contributors
and
breaking
this
up
like
this.
It
was
one
of
the
things
I
really
was
thinking
about.
Is
that
I
don't
want
anyone
to
have
to
understand
all
of
this
and
what
you
care
about
is
understanding
how
to
make
strings
from
a
structure.
Then
you
can
work
on
that
part.
What
you
care
about
is
how
do
you
test
these?
B
You
can
work
on
that
part,
so
it
was
a
big
part
of
the
way
I
was
thinking
as
I
was
putting
this
together.
So
this
unit
test
example.
I
will
make
this
public,
it
is
kathleen
dollard
on
github
and
then
it
is
starfruit
2
and
it
is
not
yet
public.
I
started
private,
but
I
decided
this
morning
when
I
decided
I
wanted
to
share
this
with
you
all,
I'm
so
excited
about
it.
I
decided
that
I
would
make
it
public
as
soon
as
I
finished
this
talk.
B
I
would
have
done
it
beforehand,
but
I
ran
out
of
time
at
a
previous
meeting,
so
yeah,
okay,
anything
else
down
in
the
chat.
I
should
okay,
so
this
uses
this
uses
something
you
may
not
have
used
before,
which
is
dot
net
interactive.
So
let
me
open
up
the
project
file
for
a
minute
and
you
will
see
net
interactive
as
soon
as
I
find
it
right
here.
Packagereference.Net,
interactive,
okay,
so
net
interactive
is
work.
That's
come
out
of
the
team
that
also
did
try.net.
B
It
has
been
expanding
and
it's
the
way
that
we
do.
The
interactive
works
in
jupyter,
notebooks,
dot
net
interactive
works
in
c
sharp.
You
may
have
seen
this
demoed,
because
what
it
lets
you
do
is
have
a
little
block
that
has
a
block
that
has
code
and
then
you
execute
it,
and
then
you
get
the
result
right
there
and
that
result
might
be
a
big
beautiful
graph.
It
might
be
a
pong
game,
I
mean
it
could
be
anything
but
whatever
it
is
that
that
you're
doing
then
is
displayed
in
place.
B
And
then
you
write
a
little
more
code
and
all
of
that
builds
up
the
idea
of
a
submission,
and
so
you
wind
up
I'm
sorry.
The
idea
of
a
kernel
and
the
instance
of
a
kernel
has
a
set
of
code
in
it.
So
the
set
of
code
that
you
have
and
let
me
just
keep
this
open
the
set
of
code.
That's
in
the
kernel
right
now,
is
what
you
can
run.
B
So
the
c-sharp
kernel
we
create
one,
and
let
me
close
this
one
for
a
second,
because
this
is
the
one
I
care
about
right
now
and
when
I
was
going
over
this
with
with
somebody,
then
I-
and
I
have
to
laugh
about
this,
and
I
didn't
don't
know
if
I
should
say
this
or
not,
but
the
contributor
is
actually
my
son
and
there's
points
in
your
in
your
life
as
a
parent.
That's
like
first
day
of
kindergarten,
they're
very
super
exciting
and
my
son
becoming
a
professional
programmer.
B
All
that
awesome,
you
know
he's
all
this
stuff
is
great,
but
then,
with
he's
contributing
to
your
open
source
project,
that's
so
exciting!
So
I'm
super
happy
about.
He
has
a
great
programmer.
Okay.
So
anyway,
when
I
was
explaining
to
this,
he
said:
if
you
don't
tell
me
where
range
act
and
assert,
is
I'm
lost?
Okay,
so
first
we
get
the
kernel
ready.
B
Then
we
do
an
act
which
is
to
submit
to
the
kernel
and
then
we
do
a
check
which
is
do
we
have
any
errors?
So
now,
if
I
run
this
it's
going
to
pass,
I
want
to
run
it.
I
want
you
to
know
it
passed
if
I
can
get
it
to
up
here,
it
will
pass
and
I'm
going
to
actually
step
through
the
next
one,
I'm
not
going
to
step
through
this
one.
This
is
what
compiled.
Does
it
work?
Okay,
so
any
questions.
Yet
when
will
it
be
usable
in
vs
code?
B
B
First,
we
need
to
tell
the
kernel
about
what
we're
running
and
then
we
need
to
run
it
so
the
first
one
is
actually
now
part
of
the
arrange,
so
we're
going
to
check
and
we
are
going
to
make
sure
we
don't
have
errors,
because
there's
no
sense
in
continuing
and
our
ability
to
debug
the
test
would
then
be
extremely
confusing.
So
here
I
am
going
to
debug
this
except
I
have
my
previous
test.
Still
running
what
what's
going
on,
why
can't
I
run
this
is
bad.
B
B
So
why
don't
we
talk
while
I
restart
visual
studio,
which
is
extremely
annoying,
but
is
probably
the
best
thing
to
do
right
now
and
I'll
close
the
source
generators
as
well,
because
I
don't
know
exactly
what's
going
on
preview.
I
was
in
this
preview
because
I
thought
it
would
be
the
stable
one.
So,
let's
see
how
this
goes
any
questions,
while
this
is
starting
back
up,
it's
visual
studio.
So,
as
you
know,
it
will
take
just
a
minute.
B
C
C
There's
also
been
plenty
of
focus
on
the
tooling
side
of
stuff,
like
the
tooling
is
a
lot
better
than
it
was
when
the
very
first
previous
stuff
came
out,
but
this
is
definitely
an
example
of
the
sort
of
thing
that
we're
going
to
keep
looking
at
as
we
continue
to
evolve.
The
entire
experience
around
source
generators,
especially
once
the
compiler
layer
of
it,
is
stable.
A
A
B
Yeah
yeah
yeah
and
the
the
future,
the
the
things
that
did
get
focused
were
the
things
that
are
most
critical,
which
is.
Can
you
see
the
code
that
gets
generated
behind
what's
going
on
and
that
was
considered
an
absolutely
must-have
for
net.net
five?
You
might
have
noticed
that
the
formatting
was
pretty
yucky
and
some
of
the
code
that
I
jumped
into
and
that's
because
that's
something
that's
considered,
we
can
do
that
later.
We
can.
We
can
make
the
formatting
good
later.
Ideally,
the
generated
code
would
pop
up
with
your
editor
config
formatting
applied.
B
B
We
actually
have
we're
debugging,
let's
clap
yeah.
I
thank
you
all
for
your
patience
to
get
here.
I
don't
know
quite
what
got
us
this
far,
but
this
is
what
I
want
to
show
you
and
then
we'll
look
at
any
questions,
so
I'm
setting
some
variables
some
stuff.
This
isn't
very
interesting.
I
have
some
test
data
that
contains
just
it's
just
gives
me
some
source
to
start
with
and
remember
each
of
those
steps,
I'm
testing
separately.
B
So
I'm
not
going
back
to
creating
the
syntax
tree,
creating
the
intermediate
structure
creating
the
source
code.
I
don't
want
to
do
that.
I
want
to
create
a
fake
intermediate
structure
which
is
in
test
data
and
in
this
case
I
actually
want
to
go
further.
I
want
to
create
fake
strings,
so
I'm
not
also
testing
the
step
between
the
inner
structure
and
the
string.
B
So
I
have
a
string
ready
to
go
and
that
string
looks
like
this
will
and
I'm
not
getting
that
popping
up
as
a
but
I'll
show
you
in
just
a
second,
so
it's
really
small
to
see,
but
it's
just
bar
command
equals
new
command
and
then
return
command.
It's
just
super
short,
it's
just
what
the
inner
that
method
would
be,
and
then
I
will
go
to
this
and
unfortunately
my
immediate
window
may
be
too
small
to
see.
But
I
will
try
I'll
say
the
generated
source.
B
Good,
okay,
so
I'm
sorry
for
all
the
slash
ends
in
there,
but
it's
using
system
command
line
puppet
class.
My
class
public
command
get
command,
so
it's
a
public
method,
returning
a
command
and
then
it's
var
command
equals
new
command.
So
it's
just
a
simple
thing,
but
command
is
a
class
in
system
command
line
and
I'm
creating
an
instance
of
that.
So
the
next
thing
I
want
to
do
is
make
sure
that
that
code
is
good
because
everything
else
fails.
B
B
My
machine
is
definitely
on
shaky
ground
right
now,
so
if
I
just
disappear
in
a
puff
of
smoke,
that's
what's
happening.
Emo
and-
and
philip
will
finish
up,
because
my
machine
is
definitely
so
at
this
point.
Yes,
I
compiled
that
code,
just
fine
and
now
so
it's
in
the
kernel.
So
that's
a
class
called
my
class
with
a
method
called
my
whatever
I
called
it
get
command
the
class
called
get
command
and
that
is
sitting
inside
the
kernel
waiting
to
be
called.
So
I'm
going
to
do
a
second
submission
which
is
going
to
be.
B
B
It
didn't
do
anything
this
one
says:
oh
I'm
going
to
get
an
ex
I'm
giving
you
an
expression,
you're
going
to
give
me
something
back,
so
the
expression
I'm
giving
is
new
class
name
method
that
was
previously
defined
normal
string,
literals,
and
so
then
I'm
going
to
run
that
and
I'm
going
to
make
sure
I
don't
have
an
error
and
again,
oh
that
was
fast
all
right.
So
now
I
make
sure
I
have
no
errors.
I
have
no
errors
and
now
the
result,
with
instance,
is
a
result.
B
I'm
gonna
then
get
the
value
out
of
that.
Okay.
So
now
foo
is
a
to
the
return
value
which
is
at
this
point.
I
don't
think
it's
typed.
I
didn't
think
it
was
typed
when
I
did
this
because
then
I
went
ahead
and
did
the
cast
right
there
and
now
the
command
has
a
property
called
name,
and
it
should
be
my
class
now
you'll
notice.
B
This
is
not
exactly
what
we
started
with
and
that
difference
is
because
syst
my
code,
the
the
code,
the
the
work
I'm
doing-
includes
changing
from
a
c
sharp
friendly
name
of
my
class
to
a
kebab
case
expected
in
pos-x,
and
so
that's
part
of
what
happens
going
into
that
interim
structure
and
our
test
passes
yay,
okay.
So
that
was
a
lot
of
stuff,
but
I'm
I'm.
B
I
can
absolutely
say
that
complex
generators
can
be
written
in
a
way
that
our
unit
test-
I
I'm
quite
confident,
we've
gotten
to
that
and
I'm
pleased
to
have
have
other
people
may
have
a
different
approach.
This
I'm
not
going
to
suggest
this
is
the
only
approach
to
doing
unit
testing
for
source
generators.
But
this
is
an
approach,
and
so
I
feel
really
good
about
that.
C
B
B
I
just
have
to
say
that
it's
all
on
a
surface,
just
a
little
tiny
pound
and
a
half
machine,
so
yeah
all
right.
So
the
test
explorer
issue
on
camera.
I'm
gonna
have
to
follow
up
on
that.
If
you
want
to
make
sure
we
know
which
one
you're
talking
about
test
explorer
is
evolving.
It
is
getting
better.
We
keep
making
it
better,
but
it
still
has
a
ways
to
go.
So
I
I
will,
I
don't
know
which
problem
you
picked
up
on
the
screen
there
and
thanks
for
coming
from
vietnam.
That's
great.
B
Yeah
and
if
you
like,
let's
kind
of
deep
dive
into
something
as
opposed
to
when
we
just
like
talk,
you
know
talk
about
a
lot
of
different
things
and
go.
You
know
five
to
ten
minutes
into
four
or
five
topics.
If
you
want
to
let
us
which
know
which
way
you
like
this
to
go
our
overall
idea
here
is
so
you
know,
what's
going
on
with
team,
that
that's
that's
what
and
we're
big
lots
of
people
on
the
team
so.
B
Popping
up
star
for
star
star
star,
I'm
not
sure
what
star
star
star
is
there
the
use
cases
for
source
generator?
You
know
what
I'm
doing
here
is.
I
can
show
you
super
quick
is
right.
Here
is
rather
than
you
having
to
know
anything
about
about
system
command
line.
I
want
you
to
be
able
to
write
a
class
that
looks
something
like
this.
Probably
with
some
attributes.
B
A
B
Oh
well,
there's
a
lot
of
teams
inside
of
microsoft
right
now
that
are
looking
at
this
feature,
just
like
there's
a
lot
of
people
outside
microsoft.
Thinking
about
this
feature-
and
there
are
definitely
places
that
reflection
is
being
used
today-
that
people
are
looking
at
whether
or
not
it's
the
right
thing
to
use
going
forward.
So
exactly
what
you
have
in
mind
and
exactly
whether
that's
a
good
use
of
it
would
require
knowing
things
I
don't
know,
including
whether
there
is
a
rosin
compilation
step
that
is
in
play.
A
A
You
don't
have
to
think
about
it
and
that's
kind
of
the
goal
with
source
generators
in
general
that
we
try
to
get
framework
authors,
library,
authors
to
find
creative
uses
for
those,
and
so
that,
when
you're
consuming
a
new
package
that
happens
to
use
a
source
generator,
it's
not
something
that
you
have
to
think
about.
It
just
means
you
know:
code
gets
generated
at
compile
time
rather
than
at
runtime.
B
Yeah,
I
think
the
length
is
a
super
important
thing
to
to
point
out
and
also
when
we're
looking
at
some
of
the
experiences
around
this
just
to
let
people
know
we're
ahead
of
where
we
thought
we
would
be
with
adoption
on
source
generators
by
like
maybe
a
year,
where
we're
seeing
a
lot
more
interest
to
people
doing
a
lot
more
broad
things.
It
was
sort
of
a
hey
there's,
some
people
that
have
some
ideas,
we'll
see
what
they're
going
to
do
with
it.
B
There's
a
lot
of
people
with
a
lot
of
ideas,
doing
a
lot
of
different
things.
So
it's
it's
definitely
going
well,
but
it
also
means
that
we're
we're
playing
catch
up
with
the
community
on
that,
especially
in
the
visual
studio
aspects
of
it,
like
I
didn't
know,
and
there
may
be
a
way
to
do
it,
but
I
didn't
know
how
to
jump
into
that
other
half
of
that
class
from
one
partial
to
another,
when
the
other
partial
is
sitting
out
in
temporary
space.
B
B
Off
is
it
possible
to
use
source
generators
without
visual
studio?
Have
a
good
dev
experience?
I
don't
know
what
the
jumping
around
experience
is
going
to
be
in
vs
code
or
something
else.
So
I
want
to
just
narrow
down
what
I'm
seeing
here.
So
all
of
the
you
know
all
the
code
I
showed
runs
in
anything
and
you
know
there's
a
ton
of
things
that
you're
going
to
be
able
to
do
across
different
environments.
This
is
a
compiler
feature,
so
it
will
run.
B
A
That
is
referenced
as
a
nuget
package
and
then
it's
easier
because
then
every
time
you
edit
your
code,
the
generator
doesn't
have
to
get
recompiled
every
time
right,
and
that
makes
it
a
lot
easier,
but
that
I
think
we
need
to
make
the
experience
better,
because
my
from
I
would
say
there
are
certainly
cases
where
the
generator
has
general
purpose
and
is
shipped
as
a
nuget
package.
But
in
many
ways
you
want
the
generator
to
be
part
of
your
project,
because
it's
very
specific
to
your
project.
It's
like.
A
Well,
I
have
this
xml
file
or
I
have
this
one
csv
file
and
I
want
to
generate
code
in
a
very
specific
way,
and
I
don't
want
to
ship
this
to
the
world
because
well,
it's
really
only
applicable
to
this
one
project
right
and
I
feel
like
that's
where
the
experience
today
is
rough,
but
I
don't
think
that's
a
vs
versus
the
problem.
That's
more
conceptual
problem
of
how
do
we
make
this
efficient
and
how
do
we
allow
users
to
reason
about
the
experience
but
yeah.
B
A
B
What
you're
talking
about,
which
is
a
very
specific
experience,
you
know.
One
way
that
would
be
a
pretty
smooth
path
today
is
for
you
to
use
a
a
different
nuget
feed
that
could
point
to
a
local
directory
and
then,
even
if
it's
in
your
solution,
it's
not
going
to
use
a
project
reference,
it's
just
going
to
bounce
out
to
the
dll.
B
If
you
have
that
as
a
feed,
so
that's
one
way
that
you
can
do
it
today,
but
in
visual
studio,
I'm
pretty
sure
you
have
to
restart
if
you
change
an
analyzer
or
a
loading
and
analyzer.
If
you
change
it,
I
think
if
it's
new,
I
mean
that's,
not
a
problem,
but
when
you
have
one
and
it's
loaded,
I
don't
think
it's
very
smart
about
saying
toss
this
one
away
and
get
the
new
copy
of
it.
A
So
this
is
why
interactive
development
of
the
generator
sucks
today,
but
once
you
have
the
generator
and
if
it's
in
your
solution
and
doesn't
change
and
the
only
thing
that
changes
the
generated
code,
that
experience
works
already
very
well
and
that's
where
vs
code
needs
to
do
some
catch-up
work.
But
I
think
the
yeah,
the
experience
of
you
interactively
editing
the
generator.
That's
the
hard
part,
and
maybe
there's
a
some
gesture
where
you
can
say
right,
click
invalidate
or
something
right,
or
maybe
it's
automatic.
But
yeah
we'll
see.
B
Yeah
I
just
I
was
I'm
insisting
on
staying
away
from
that
that
you
know,
I'm
gonna
have
full
confidence
when
I
drop
the
generator
in,
and
I'm
excited
about
that
but
yeah
it's.
So
I
think
that,
right
now
today,
what
am
I
saying
is:
if
you're
gonna
write
a
generator,
I
definitely
would
go
to
the
fully
deeply
unit
tested
first.
So
when
you
drop
it
in
and
remember
your
input
eventually,
whatever
many
steps
you
have,
one
or
more,
your
input
needs
to
be.
B
What's
going
to
be
the
input
to
that
source
generator
which
is
going
to
be,
you
can
look
at
one
of
the
generators
and
see
how
you
get
a
semantic
model
and
it's
going
to
be
the
context
which
has
the
ability
to
make
semantic
model
from
the
syntax
tree.
So
that's
what
you're
going
to
get
so
you're
going
to
get
what
you
need
and
then,
if
you're
going
to
do
a
receiver,
syntax
receiver,
getting
your
candidates
in
there
and
have
that
be
the?