OpShin / opshin / 693

pending completion

Build # 693

Build Type

Pull #126

travis-ci-com

Committed by

web-flow

Commit Message

Merge 8897aa598 into 137444d4e

Pull Request Pull Request #126: Fix upcasting by using annotated assignment

Run Details

15 of 15 new or added lines in 3 files covered. (100.0%)

3278 of 3548 relevant lines covered (92.39%)

3.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.31

/opshin/rewrite/rewrite_import_hashlib.py

from typing import Optional
from enum import Enum

from ..util import CompilingNodeTransformer
from ..typed_ast import *

"""
Checks that there was an import of dataclass if there are any class definitions
"""


@dataclass(frozen=True, unsafe_hash=True)
class HashType(ClassType):
    """A pseudo class that is the result of python hash functions that need a 'digest' call"""

    def attribute_type(self, attr) -> "Type":
        if attr == "digest":
            return InstanceType(FunctionType([], ByteStringInstanceType))
        raise NotImplementedError("HashType only has attribute 'digest'")

    def attribute(self, attr) -> plt.AST:
        if attr == "digest":
            return plt.Lambda(["self"], plt.Var("self"))
        raise NotImplementedError("HashType only has attribute 'digest'")

    def __ge__(self, other):
        return isinstance(other, HashType)


HashInstanceType = InstanceType(HashType())


class PythonHashlib(Enum):
    sha256 = plt.Lambda(["x", "_"], plt.Lambda(["_"], plt.Sha2_256(plt.Var("x"))))
    sha3_256 = plt.Lambda(["x", "_"], plt.Lambda(["_"], plt.Sha3_256(plt.Var("x"))))
    blake2b = plt.Lambda(["x", "_"], plt.Lambda(["_"], plt.Blake2b_256(plt.Var("x"))))


PythonHashlibTypes = {
    PythonHashlib.sha256: InstanceType(
        FunctionType(
            [ByteStringInstanceType],
            HashInstanceType,
        )
    ),
    PythonHashlib.sha3_256: InstanceType(
        FunctionType(
            [ByteStringInstanceType],
            HashInstanceType,
        )
    ),
    PythonHashlib.blake2b: InstanceType(
        FunctionType(
            [ByteStringInstanceType],
            HashInstanceType,
        )
    ),
}


class RewriteImportHashlib(CompilingNodeTransformer):
    step = "Resolving imports and usage of hashlib"

    imports_hashlib = False

    def visit_ImportFrom(self, node: ImportFrom) -> typing.List[AST]:
        if node.module != "hashlib":
            return node
        additional_assigns = []
        for n in node.names:
            imported_fun = None
            for h in PythonHashlib:
                if h.name == n.name:
                    imported_fun = h
            assert (
                imported_fun is not None
            ), f"Unsupported function import from hashlib '{n.name}"
            typ = PythonHashlibTypes[imported_fun]
            imported_name = n.name if n.asname is None else n.asname
            additional_assigns.append(
                TypedAssign(
                    targets=[TypedName(id=imported_name, typ=typ, ctx=Store())],
                    value=RawPlutoExpr(
                        typ=typ, expr=plt.Lambda(["_"], imported_fun.value)
                    ),
                )
            )
        return additional_assigns

1	from typing import Optional	4✔
2	from enum import Enum	4✔
3
4	from ..util import CompilingNodeTransformer	4✔
5	from ..typed_ast import *	4✔
6
7	"""	2✔
8	Checks that there was an import of dataclass if there are any class definitions
9	"""
10
11
12	@dataclass(frozen=True, unsafe_hash=True)	4✔
13	class HashType(ClassType):	4✔
14	"""A pseudo class that is the result of python hash functions that need a 'digest' call"""
15
16	def attribute_type(self, attr) -> "Type":	4✔
17	if attr == "digest":	4✔
18	return InstanceType(FunctionType([], ByteStringInstanceType))	4✔
19	raise NotImplementedError("HashType only has attribute 'digest'")	×
20
21	def attribute(self, attr) -> plt.AST:	4✔
22	if attr == "digest":	4✔
23	return plt.Lambda(["self"], plt.Var("self"))	4✔
24	raise NotImplementedError("HashType only has attribute 'digest'")	×
25
26	def __ge__(self, other):	4✔
27	return isinstance(other, HashType)	×
28
29
30	HashInstanceType = InstanceType(HashType())	4✔
31
32
33	class PythonHashlib(Enum):	4✔
34	sha256 = plt.Lambda(["x", "_"], plt.Lambda(["_"], plt.Sha2_256(plt.Var("x"))))	4✔
35	sha3_256 = plt.Lambda(["x", "_"], plt.Lambda(["_"], plt.Sha3_256(plt.Var("x"))))	4✔
36	blake2b = plt.Lambda(["x", "_"], plt.Lambda(["_"], plt.Blake2b_256(plt.Var("x"))))	4✔
37
38
39	PythonHashlibTypes = {	4✔
40	PythonHashlib.sha256: InstanceType(
41	FunctionType(
42	[ByteStringInstanceType],
43	HashInstanceType,
44	)
45	),
46	PythonHashlib.sha3_256: InstanceType(
47	FunctionType(
48	[ByteStringInstanceType],
49	HashInstanceType,
50	)
51	),
52	PythonHashlib.blake2b: InstanceType(
53	FunctionType(
54	[ByteStringInstanceType],
55	HashInstanceType,
56	)
57	),
58	}
59
60
61	class RewriteImportHashlib(CompilingNodeTransformer):	4✔
62	step = "Resolving imports and usage of hashlib"	4✔
63
64	imports_hashlib = False	4✔
65
66	def visit_ImportFrom(self, node: ImportFrom) -> typing.List[AST]:	4✔
67	if node.module != "hashlib":	4✔
68	return node	4✔
69	additional_assigns = []	4✔
70	for n in node.names:	4✔
71	imported_fun = None	4✔
72	for h in PythonHashlib:	4✔
73	if h.name == n.name:	4✔
74	imported_fun = h	4✔
75	assert (	4✔
76	imported_fun is not None
77	), f"Unsupported function import from hashlib '{n.name}"
78	typ = PythonHashlibTypes[imported_fun]	4✔
79	imported_name = n.name if n.asname is None else n.asname	4✔
80	additional_assigns.append(	4✔
81	TypedAssign(
82	targets=[TypedName(id=imported_name, typ=typ, ctx=Store())],
83	value=RawPlutoExpr(
84	typ=typ, expr=plt.Lambda(["_"], imported_fun.value)
85	),
86	)
87	)
88	return additional_assigns	4✔

OpShin / opshin / 693

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous