Process subroutine type annotations

[jasonpaulos]

Summary

Currently subroutine function type annotations are not processed by the compiler. In order for these annotations to remain truthful (which allows mypy to do proper type checking), they should always be Expr if present.

For example:

from pyteal import *

# acceptable annotations
@Subroutine(TealType.uint64)
def mySubroutineValid(a: Expr, b: Expr) -> Expr:
    return a + b

# unacceptable annotations
@Subroutine(TealType.uint64)
def mySubroutineInvalid(a: TealType.uint64, b: TealType.uint64) -> TealType.uint64:
    return a + b

The second subroutine represents an invalid use of type annotations because the types are not valid at the Python level -- the arguments and return values are PyTeal Exprs, not TealTypes.

Scope

Extend SubroutineDefinition to analyze and remember the type annotations for all arguments and the return type. If annotations are present, they must be Expr (I suppose the return type might be a more specific subclass of Expr, but I don't think this is important enough to allow). If no annotations are present, then assume that all values are annotated with Expr.

[tzaffi]

@jasonpaulos - what if we have partial annotations, which are all individually valid. For example:

@Subroutine(TealType.uint64)
def mySubroutineValid(a: Expr, b) -> Expr:
    return a + b

# or

@Subroutine(TealType.uint64)
def mySubroutineValid(a: Expr, b: Expr):
    return a + b

# or 

@Subroutine(TealType.uint64)
def mySubroutineValid(a, b) -> Expr:
    return a + b

Should we just go ahead and fill in the missing annotations as Expr?

Also, I see that class SubroutineDefinition has a Callable member named implementation. Out of the box it has an __annotations__ field which stores the annotations. So in theory, we are already "remembering" the annotations. Is this sufficient, or were you envisioning something else, such as propagating the annotation up to the decorating wrapper function?

[jasonpaulos]

@jasonpaulos - what if we have partial annotations, which are all individually valid. For example:

...

Should we just go ahead and fill in the missing annotations as Expr?

I think defaulting to Expr makes the most sense if some parts aren't annotated.

Also, I see that class SubroutineDefinition has a Callable member named implementation. Out of the box it has an __annotations__ field which stores the annotations. So in theory, we are already "remembering" the annotations. Is this sufficient, or were you envisioning something else, such as propagating the annotation up to the decorating wrapper function?

I was not aware of that. As long as we can extract the annotations for use later, that seems fine to me.

[tzaffi]

How about the case referenced in #159 ?

It seems we also would want to support the ScratchVar interface type. But maybe the PR handling that issue should modify appropriately.

[jasonpaulos]

Yes, I think this PR should restrict to only Expr, then when #159 is implemented, it should allow ScratchVar as well.