Mojom frontend: Detect Ill-founded Types

mojom/mojom_tool/serialization/serialization_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package serialization
 
 import (
         "bytes"
         "compress/gzip"
         "encoding/base64"
@@ skipping 1130 matching lines @@
                         continue
                 }
                 if err := descriptor.Resolve(); err != nil {
                         t.Errorf("Resolve error for %s: %s", c.fileName, err.Error())
                         continue
                 }
                 if err := descriptor.ComputeFinalData(); err != nil {
                         t.Errorf("ComputeFinalData error for %s: %s", c.fileName, err.Error())
                         continue
                 }
+                if err := descriptor.DetectIllFoundedTypes(); err != nil {
+                        t.Errorf("DetectIllFoundedTypes error for %s: %s", c.fileName, err.Error())
+                        continue
+                }
 
                 // Simulate setting the canonical file name for the imported files. In real operation
                 // this step is done in parser_driver.go when each of the imported files are parsed.
                 mojomFile := parser.GetMojomFile()
                 if mojomFile.Imports != nil {
                         for _, imp := range mojomFile.Imports {
                                 imp.CanonicalFileName = fmt.Sprintf("%s.canonical", imp.SpecifiedName)
                         }
                 }
 
@@ skipping 914 matching lines @@
         ////////////////////////////////////////////////////////////
         {
                 contents := `
         union MyUnion1{};
 
         interface MyInterface1{};
 
         struct MyStruct1 {
           int8          x;
           MyUnion1      my_union;
-          MyStruct1     my_struct;
+          MyStruct1?    my_struct;
           MyInterface1& my_interface_request;
           int32         y;
           MyInterface1  my_interface;
         };`
 
                 test.addTestCase("", contents)
 
                 test.expectedFile().DeclaredMojomObjects.Unions = &[]string{"TYPE_KEY:MyUnion1"}
                 test.expectedFile().DeclaredMojomObjects.Interfaces = &[]string{"TYPE_KEY:MyInterface1"}
                 test.expectedFile().DeclaredMojomObjects.Structs = &[]string{"TYPE_KEY:MyStruct1"}
@@ skipping 14 matching lines @@
                                 {
                                         DeclData: test.newShortDeclDataO(1, -1, "my_union"),
                                         Type: &mojom_types.TypeTypeReference{mojom_types.TypeReference{
                                                 false, false, stringPointer("MyUnion1"), stringPointer("TYPE_KEY:MyUnion1")}},
                                         Offset: 8,
                                 },
                                 // field my_struct
                                 {
                                         DeclData: test.newShortDeclDataO(2, -1, "my_struct"),
                                         Type: &mojom_types.TypeTypeReference{mojom_types.TypeReference{
-                                                false, false, stringPointer("MyStruct1"), stringPointer("TYPE_KEY:MyStruct1")}},
+                                                true, false, stringPointer("MyStruct1"), stringPointer("TYPE_KEY:MyStruct1")}},
                                         Offset: 24,
                                 },
                                 // field my_interface_request
                                 {
                                         DeclData: test.newShortDeclDataO(3, -1, "my_interface_request"),
                                         Type: &mojom_types.TypeTypeReference{mojom_types.TypeReference{
                                                 false, true, stringPointer("MyInterface1"), stringPointer("TYPE_KEY:MyInterface1")}},
                                         Offset: 4,
                                 },
                                 // field y
@@ skipping 43 matching lines @@
         ////////////////////////////////////////////////////////////
         {
                 contents := `
         union MyUnion1{};
 
         interface MyInterface1{};
 
         struct MyStruct1 {
           int8          x;
           MyUnion1      my_union;
-          MyStruct1     my_struct;
+          MyStruct1?    my_struct;
 
           [MinVersion=1]
           MyInterface1&? my_interface_request;
 
           [MinVersion=2]
           int32       y;
 
           [MinVersion=2]
           MyInterface1?  my_interface;
         };`
@@ skipping 20 matching lines @@
                                 {
                                         DeclData: test.newShortDeclDataO(1, -1, "my_union"),
                                         Type: &mojom_types.TypeTypeReference{mojom_types.TypeReference{
                                                 false, false, stringPointer("MyUnion1"), stringPointer("TYPE_KEY:MyUnion1")}},
                                         Offset: 8,
                                 },
                                 // field my_struct
                                 {
                                         DeclData: test.newShortDeclDataO(2, -1, "my_struct"),
                                         Type: &mojom_types.TypeTypeReference{mojom_types.TypeReference{
-                                                false, false, stringPointer("MyStruct1"), stringPointer("TYPE_KEY:MyStruct1")}},
+                                                true, false, stringPointer("MyStruct1"), stringPointer("TYPE_KEY:MyStruct1")}},
                                         Offset: 24,
                                 },
                                 // field my_interface_request
                                 {
                                         DeclData: test.newShortDeclDataAO(3, -1, "my_interface_request", &[]mojom_types.Attribute{{"MinVersion", &mojom_types.LiteralValueInt8Value{1}}}),
                                         Type: &mojom_types.TypeTypeReference{mojom_types.TypeReference{
                                                 true, true, stringPointer("MyInterface1"), stringPointer("TYPE_KEY:MyInterface1")}},
                                         Offset:     4,
                                         MinVersion: 1,
                                 },
@@ skipping 60 matching lines @@
                         continue
                 }
                 if err := descriptor.Resolve(); err != nil {
                         t.Errorf("Resolve error for %s: %s", c.fileName, err.Error())
                         continue
                 }
                 if err := descriptor.ComputeFinalData(); err != nil {
                         t.Errorf("ComputeFinalData error for %s: %s", c.fileName, err.Error())
                         continue
                 }
+                if err := descriptor.DetectIllFoundedTypes(); err != nil {
+                        t.Errorf("DetectIllFoundedTypes error for %s: %s", c.fileName, err.Error())
+                        continue
+                }
 
                 // Simulate setting the canonical file name for the imported files. In real operation
                 // this step is done in parser_driver.go when each of the imported files are parsed.
                 mojomFile := parser.GetMojomFile()
                 if mojomFile.Imports != nil {
                         for _, imp := range mojomFile.Imports {
                                 imp.CanonicalFileName = fmt.Sprintf("%s.canonical", imp.SpecifiedName)
                         }
                 }
 
@@ skipping 89 matching lines @@
                         continue
                 }
                 if err := descriptor.Resolve(); err != nil {
                         t.Errorf("Resolve error for %s: %s", c.fileName, err.Error())
                         continue
                 }
                 if err := descriptor.ComputeFinalData(); err != nil {
                         t.Errorf("ComputeFinalData error for %s: %s", c.fileName, err.Error())
                         continue
                 }
+                if err := descriptor.DetectIllFoundedTypes(); err != nil {
+                        t.Errorf("DetectIllFoundedTypes error for %s: %s", c.fileName, err.Error())
+                        continue
+                }
 
                 // Serialize
                 bytes, _, err := serialize(descriptor, false, false, c.lineAndcolumnNumbers, false)
                 if err != nil {
                         t.Errorf("Serialization error for %s: %s", c.fileName, err.Error())
                         continue
                 }
 
                 // Deserialize
                 decoder := bindings.NewDecoder(bytes, nil)
@@ skipping 255 matching lines @@
 
                 // Resolve
                 if err := descriptor.Resolve(); err != nil {
                         t.Errorf("Resolve error for case %d: %s", i, err.Error())
                         continue
                 }
                 if err := descriptor.ComputeFinalData(); err != nil {
                         t.Errorf("ComputeFinalData error for case %d: %s", i, err.Error())
                         continue
                 }
+                if err := descriptor.DetectIllFoundedTypes(); err != nil {
+                        t.Errorf("DetectIllFoundedTypes error for case %d: %s", i, err.Error())
+                        continue
+                }
 
                 // Serialize
                 bytes, _, err := serialize(descriptor, false, false, c.lineAndcolumnNumbers, false)
                 if err != nil {
                         t.Errorf("Serialization error for case %d: %s", i, err.Error())
                         continue
                 }
 
                 // Deserialize
                 decoder := bindings.NewDecoder(bytes, nil)
@@ skipping 589 matching lines @@
 
                 // Resolve
                 if err := descriptor.Resolve(); err != nil {
                         t.Errorf("Resolve error for case %d: %s", i, err.Error())
                         continue
                 }
                 if err := descriptor.ComputeFinalData(); err != nil {
                         t.Errorf("ComputeFinalData error for case %d: %s", i, err.Error())
                         continue
                 }
+                if err := descriptor.DetectIllFoundedTypes(); err != nil {
+                        t.Errorf("DetectIllFoundedTypes error for case %d: %s", i, err.Error())
+                        continue
+                }
 
                 // Serialize
                 bytes, _, err := serialize(descriptor, false, false, false, true)
                 if err != nil {
                         t.Errorf("Serialization error for case %d: %s", i, err.Error())
                         continue
                 }
 
                 // Deserialize
                 decoder := bindings.NewDecoder(bytes, nil)
@@ skipping 68 matching lines @@
                         }
                         return fmt.Errorf("*****\nexpected=\n*****\n%q\n*****\nactual=\n*****\n%q\n*****\n"+
                                 "match failed at position %d: expected=\n*****\n%q\n******\nactual=\n*****\n%q\n******\n",
                                 expectedString, actualString, diffPos, mismatchExpected, mismatchActual)
                 } else {
                         return fmt.Errorf("expected != actual but the two printed equal.")
                 }
         }
         return nil
 }