Skip to content

Commit 78654f1

Browse files
MingunMingun
committed
Use Ast.EnumRef everywhere instead of Ast.typeId + Ast.identifier
Because of new types type system enforses fixing kaitai-io/kaitai_struct#857 This test need to be updated: [info] - expr_compare_enum2 *** FAILED *** [info] [expr_compare_enum2.ksy: /seq/1/if: [info] error: can't compare EnumType(EnumRef(false,List(),animal),Int1Type(false)) and Int1Type(true) [info] ] [info] did not equal [info] [expr_compare_enum2.ksy: /seq/1/if: [info] error: can't compare EnumType(List(animal),Int1Type(false)) and Int1Type(true) [info] ] (SimpleMatchers.scala:34)
1 parent ad24698 commit 78654f1

16 files changed

Lines changed: 103 additions & 107 deletions

File tree

‎jvm/src/test/scala/io/kaitai/struct/ClassTypeProvider$Test.scala‎

Lines changed: 50 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -624,35 +624,36 @@ class ClassTypeProvider$Test extends AnyFunSpec {
624624
val e_12 = child_12.enums.get("e").getOrElse(throw new NoSuchElementException("'e_12' not found"))
625625
val e_2 = child_2.enums.get("e").getOrElse(throw new NoSuchElementException("'e_2' not found"))
626626

627-
val none = Ast.typeId(false, Seq())
628-
val one = Ast.typeId(false, Seq("one"))
629-
val one_two = Ast.typeId(false, Seq("one", "two"))
630-
val unknown = Ast.typeId(false, Seq("unknown"))
627+
val none = Ast.EnumRef(false, Seq(), "e")
628+
val one_e = Ast.EnumRef(false, Seq("one"), "e")
629+
val one_unk = Ast.EnumRef(false, Seq("one"), "unknown")
630+
val one_two = Ast.EnumRef(false, Seq("one", "two"), "e")
631+
val unknown = Ast.EnumRef(false, Seq("unknown"), "e")
631632

632633
describe("in 'root' context") {
633634
val resolver = new ClassTypeProvider(specs, root)
634635

635636
it("resolves 'e'") {
636-
resolver.resolveEnum(none, "e") should be(e_root)
637+
resolver.resolveEnum(none) should be(e_root)
637638
}
638639

639640
it("doesn't resolve 'one::e'") {
640-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one, "e")
641+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_e)
641642
thrown.getMessage should be("unable to find type 'one', searching from 'root'")
642643
}
643644

644645
it("doesn't resolve 'one::two::e'") {
645-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two, "e")
646+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two)
646647
thrown.getMessage should be("unable to find type 'one', searching from 'root'")
647648
}
648649

649650
it("doesn't resolve 'one::unknown'") {
650-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one, "unknown")
651+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_unk)
651652
thrown.getMessage should be("unable to find type 'one', searching from 'root'")
652653
}
653654

654655
it("doesn't resolve 'unknown::e'") {
655-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown, "e")
656+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown)
656657
thrown.getMessage should be("unable to find type 'unknown', searching from 'root'")
657658
}
658659
}
@@ -662,25 +663,25 @@ class ClassTypeProvider$Test extends AnyFunSpec {
662663
resolver.nowClass = child_1
663664

664665
it("resolves 'e'") {
665-
resolver.resolveEnum(none, "e") should be(e_root)
666+
resolver.resolveEnum(none) should be(e_root)
666667
}
667668

668669
it("resolves 'one::e'") {
669-
resolver.resolveEnum(one, "e") should be(e_11)
670+
resolver.resolveEnum(one_e) should be(e_11)
670671
}
671672

672673
it("doesn't resolve 'one::two::e'") {
673-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two, "e")
674+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two)
674675
thrown.getMessage should be("unable to find type 'two' in 'root::child_1::one'")
675676
}
676677

677678
it("doesn't resolve 'one::unknown'") {
678-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "unknown")
679+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_unk)
679680
thrown.getMessage should be("unable to find enum 'unknown' in 'root::child_1::one'")
680681
}
681682

682683
it("doesn't resolve 'unknown::e'") {
683-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown, "e")
684+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown)
684685
thrown.getMessage should be("unable to find type 'unknown', searching from 'root::child_1'")
685686
}
686687
}
@@ -690,26 +691,26 @@ class ClassTypeProvider$Test extends AnyFunSpec {
690691
resolver.nowClass = child_2
691692

692693
it("resolves 'e'") {
693-
resolver.resolveEnum(none, "e") should be(e_2)
694+
resolver.resolveEnum(none) should be(e_2)
694695
}
695696

696697
it("doesn't resolve 'one::e'") {
697-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "e")
698+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_e)
698699
thrown.getMessage should be("unable to find enum 'e' in 'root::child_2::one'")
699700
}
700701

701702
it("doesn't resolve 'one::two::e'") {
702-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two, "e")
703+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two)
703704
thrown.getMessage should be("unable to find type 'two' in 'root::child_2::one'")
704705
}
705706

706707
it("doesn't resolve 'one::unknown'") {
707-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "unknown")
708+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_unk)
708709
thrown.getMessage should be("unable to find enum 'unknown' in 'root::child_2::one'")
709710
}
710711

711712
it("doesn't resolve 'unknown::e'") {
712-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown, "e")
713+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown)
713714
thrown.getMessage should be("unable to find type 'unknown', searching from 'root::child_2'")
714715
}
715716
}
@@ -719,25 +720,25 @@ class ClassTypeProvider$Test extends AnyFunSpec {
719720
resolver.nowClass = child_11
720721

721722
it("resolves 'e'") {
722-
resolver.resolveEnum(none, "e") should be(e_11)
723+
resolver.resolveEnum(none) should be(e_11)
723724
}
724725

725726
it("resolves 'one::e'") {
726-
resolver.resolveEnum(one, "e") should be(e_11)
727+
resolver.resolveEnum(one_e) should be(e_11)
727728
}
728729

729730
it("doesn't resolve 'one::two::e'") {
730-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two, "e")
731+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two)
731732
thrown.getMessage should be("unable to find type 'two' in 'root::child_1::one'")
732733
}
733734

734735
it("doesn't resolve 'one::unknown'") {
735-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "unknown")
736+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_unk)
736737
thrown.getMessage should be("unable to find enum 'unknown' in 'root::child_1::one'")
737738
}
738739

739740
it("doesn't resolve 'unknown::e'") {
740-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown, "e")
741+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown)
741742
thrown.getMessage should be("unable to find type 'unknown', searching from 'root::child_1::one'")
742743
}
743744
}
@@ -747,26 +748,26 @@ class ClassTypeProvider$Test extends AnyFunSpec {
747748
resolver.nowClass = child_12
748749

749750
it("resolves 'e'") {
750-
resolver.resolveEnum(none, "e") should be(e_12)
751+
resolver.resolveEnum(none) should be(e_12)
751752
}
752753

753754
it("doesn't resolve 'one::e'") {
754-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "e")
755+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_e)
755756
thrown.getMessage should be("unable to find enum 'e' in 'root::child_1::two::one'")
756757
}
757758

758759
it("doesn't resolve 'one::two::e'") {
759-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two, "e")
760+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two)
760761
thrown.getMessage should be("unable to find type 'two' in 'root::child_1::two::one'")
761762
}
762763

763764
it("doesn't resolve 'one::unknown'") {
764-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "unknown")
765+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_unk)
765766
thrown.getMessage should be("unable to find enum 'unknown' in 'root::child_1::two::one'")
766767
}
767768

768769
it("doesn't resolve 'unknown::e'") {
769-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown, "e")
770+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown)
770771
thrown.getMessage should be("unable to find type 'unknown', searching from 'root::child_1::two'")
771772
}
772773
}
@@ -776,26 +777,26 @@ class ClassTypeProvider$Test extends AnyFunSpec {
776777
resolver.nowClass = child_21
777778

778779
it("resolves 'e'") {
779-
resolver.resolveEnum(none, "e") should be(e_2)
780+
resolver.resolveEnum(none) should be(e_2)
780781
}
781782

782783
it("doesn't resolve 'one::e'") {
783-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "e")
784+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_e)
784785
thrown.getMessage should be("unable to find enum 'e' in 'root::child_2::one'")
785786
}
786787

787788
it("doesn't resolve 'one::two::e'") {
788-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two, "e")
789+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two)
789790
thrown.getMessage should be("unable to find type 'two' in 'root::child_2::one'")
790791
}
791792

792793
it("doesn't resolve 'one::unknown'") {
793-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "unknown")
794+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_unk)
794795
thrown.getMessage should be("unable to find enum 'unknown' in 'root::child_2::one'")
795796
}
796797

797798
it("doesn't resolve 'unknown::e'") {
798-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown, "e")
799+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown)
799800
thrown.getMessage should be("unable to find type 'unknown', searching from 'root::child_2::one'")
800801
}
801802
}
@@ -805,26 +806,26 @@ class ClassTypeProvider$Test extends AnyFunSpec {
805806
resolver.nowClass = child_22
806807

807808
it("resolves 'e'") {
808-
resolver.resolveEnum(none, "e") should be(e_2)
809+
resolver.resolveEnum(none) should be(e_2)
809810
}
810811

811812
it("doesn't resolve 'one::e'") {
812-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "e")
813+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_e)
813814
thrown.getMessage should be("unable to find enum 'e' in 'root::child_2::one'")
814815
}
815816

816817
it("doesn't resolve 'one::two::e'") {
817-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two, "e")
818+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two)
818819
thrown.getMessage should be("unable to find type 'two' in 'root::child_2::one'")
819820
}
820821

821822
it("doesn't resolve 'one::unknown'") {
822-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "unknown")
823+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_unk)
823824
thrown.getMessage should be("unable to find enum 'unknown' in 'root::child_2::one'")
824825
}
825826

826827
it("doesn't resolve 'unknown::e'") {
827-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown, "e")
828+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown)
828829
thrown.getMessage should be("unable to find type 'unknown', searching from 'root::child_2::two'")
829830
}
830831
}
@@ -834,26 +835,26 @@ class ClassTypeProvider$Test extends AnyFunSpec {
834835
resolver.nowClass = child_121
835836

836837
it("resolves 'e'") {
837-
resolver.resolveEnum(none, "e") should be(e_12)
838+
resolver.resolveEnum(none) should be(e_12)
838839
}
839840

840841
it("doesn't resolve 'one::e'") {
841-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "e")
842+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_e)
842843
thrown.getMessage should be("unable to find enum 'e' in 'root::child_1::two::one'")
843844
}
844845

845846
it("doesn't resolve 'one::two::e'") {
846-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two, "e")
847+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two)
847848
thrown.getMessage should be("unable to find type 'two' in 'root::child_1::two::one'")
848849
}
849850

850851
it("doesn't resolve 'one::unknown'") {
851-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "unknown")
852+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_unk)
852853
thrown.getMessage should be("unable to find enum 'unknown' in 'root::child_1::two::one'")
853854
}
854855

855856
it("doesn't resolve 'unknown::e'") {
856-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown, "e")
857+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown)
857858
thrown.getMessage should be("unable to find type 'unknown', searching from 'root::child_1::two::one'")
858859
}
859860
}
@@ -863,26 +864,26 @@ class ClassTypeProvider$Test extends AnyFunSpec {
863864
resolver.nowClass = child_122
864865

865866
it("resolves 'e'") {
866-
resolver.resolveEnum(none, "e") should be(e_12)
867+
resolver.resolveEnum(none) should be(e_12)
867868
}
868869

869870
it("doesn't resolve 'one::e'") {
870-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "e")
871+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_e)
871872
thrown.getMessage should be("unable to find enum 'e' in 'root::child_1::two::one'")
872873
}
873874

874875
it("doesn't resolve 'one::two::e'") {
875-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two, "e")
876+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(one_two)
876877
thrown.getMessage should be("unable to find type 'two' in 'root::child_1::two::one'")
877878
}
878879

879880
it("doesn't resolve 'one::unknown'") {
880-
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one, "unknown")
881+
val thrown = the[EnumNotFoundError] thrownBy resolver.resolveEnum(one_unk)
881882
thrown.getMessage should be("unable to find enum 'unknown' in 'root::child_1::two::one'")
882883
}
883884

884885
it("doesn't resolve 'unknown::e'") {
885-
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown, "e")
886+
val thrown = the[TypeNotFoundError] thrownBy resolver.resolveEnum(unknown)
886887
thrown.getMessage should be("unable to find type 'unknown', searching from 'root::child_1::two::two'")
887888
}
888889
}

‎jvm/src/test/scala/io/kaitai/struct/exprlang/ExpressionsSpec.scala‎

Lines changed: 5 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -133,35 +133,32 @@ class ExpressionsSpec extends AnyFunSpec {
133133

134134
// Enums
135135
it("parses port::http") {
136-
Expressions.parse("port::http") should be (EnumByLabel(identifier("port"), identifier("http")))
136+
Expressions.parse("port::http") should be (EnumByLabel(EnumRef(false, Seq(), "port"), identifier("http")))
137137
}
138138

139139
it("parses some_type::port::http") {
140140
Expressions.parse("some_type::port::http") should be (
141141
EnumByLabel(
142-
identifier("port"),
142+
EnumRef(false, Seq("some_type"), "port"),
143143
identifier("http"),
144-
typeId(absolute = false, Seq("some_type"))
145144
)
146145
)
147146
}
148147

149148
it("parses parent_type::child_type::port::http") {
150149
Expressions.parse("parent_type::child_type::port::http") should be (
151150
EnumByLabel(
152-
identifier("port"),
151+
EnumRef(false, Seq("parent_type", "child_type"), "port"),
153152
identifier("http"),
154-
typeId(absolute = false, Seq("parent_type", "child_type"))
155153
)
156154
)
157155
}
158156

159157
it("parses ::parent_type::child_type::port::http") {
160158
Expressions.parse("::parent_type::child_type::port::http") should be (
161159
EnumByLabel(
162-
identifier("port"),
160+
EnumRef(true, Seq("parent_type", "child_type"), "port"),
163161
identifier("http"),
164-
typeId(absolute = true, Seq("parent_type", "child_type"))
165162
)
166163
)
167164
}
@@ -171,7 +168,7 @@ class ExpressionsSpec extends AnyFunSpec {
171168
Compare(
172169
BinOp(
173170
Attribute(
174-
EnumByLabel(identifier("port"),identifier("http")),
171+
EnumByLabel(EnumRef(false, Seq(), "port"), identifier("http")),
175172
identifier("to_i")
176173
),
177174
Add,

‎jvm/src/test/scala/io/kaitai/struct/translators/TestTypeProviders.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ object TestTypeProviders {
1515
abstract class FakeTypeProvider extends TypeProvider {
1616
val nowClass = ClassSpec.opaquePlaceholder(List("top_class"))
1717

18-
override def resolveEnum(inType: Ast.typeId, enumName: String) =
18+
override def resolveEnum(ref: Ast.EnumRef) =
1919
throw new NotImplementedError
2020

2121
override def resolveType(typeName: Ast.typeId): DataType = {

‎shared/src/main/scala/io/kaitai/struct/ClassTypeProvider.scala‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -117,18 +117,18 @@ class ClassTypeProvider(classSpecs: ClassSpecs, var topClass: ClassSpec) extends
117117
throw new FieldNotFoundError(attrName, inClass)
118118
}
119119

120-
override def resolveEnum(inType: Ast.typeId, enumName: String): EnumSpec = {
121-
val inClass = if (inType.absolute) topClass else nowClass
120+
override def resolveEnum(ref: Ast.EnumRef): EnumSpec = {
121+
val inClass = if (ref.absolute) topClass else nowClass
122122
// When concrete type is not defined, search enum definition in all enclosing types
123-
if (inType.names.isEmpty) {
124-
resolveEnumName(inClass, enumName)
123+
if (ref.typePath.isEmpty) {
124+
resolveEnumName(inClass, ref.name)
125125
} else {
126-
val ty = resolveTypePath(inClass, inType.names)
127-
ty.enums.get(enumName) match {
126+
val ty = resolveTypePath(inClass, ref.typePath)
127+
ty.enums.get(ref.name) match {
128128
case Some(spec) =>
129129
spec
130130
case None =>
131-
throw new EnumNotFoundInTypeError(enumName, ty)
131+
throw new EnumNotFoundInTypeError(ref.name, ty)
132132
}
133133
}
134134
}

‎shared/src/main/scala/io/kaitai/struct/GraphvizClassCompiler.scala‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -349,8 +349,8 @@ class GraphvizClassCompiler(classSpecs: ClassSpecs, topClass: ClassSpec) extends
349349
exprs.flatMap(affectedVars).toList
350350
case _: Ast.expr.EnumByLabel =>
351351
List()
352-
case Ast.expr.EnumById(_, id, _) =>
353-
affectedVars(id)
352+
case Ast.expr.EnumById(_, expr) =>
353+
affectedVars(expr)
354354
case Ast.expr.Attribute(value, attr) =>
355355
if (attr.name == Identifier.SIZEOF) {
356356
val vars = value match {

0 commit comments

Comments
 (0)