Mojom frontend: Start populating |resolved_concrete_value| field in mojom_types.mojom

mojom/mojom_tool/integration_tests/resolution_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 parser
 
 import (
         "fmt"
         "mojom/mojom_tool/mojom"
         "mojom/mojom_tool/parser"
@@ skipping 89 matching lines @@
     };`
 
                 test.addTestCase(contents, []string{
                         "Undefined type: \"Bar\"", "Undefined type: \"Baz\"",
                         "Undefined value: \"Boom\"", "Undefined value: \"Bing\"",
                         "Use of unresolved value: \"X\"",
                         "^^^^"}) // There will be four carets in the snippet because of "Boom"
         }
 
         ////////////////////////////////////////////////////////////
+        // Test Case: Circular reference of constants
+        ////////////////////////////////////////////////////////////
+        {
+                contents := `
+                const int32 MyConst1 = MyConst2;
+                const int32 MyConst2 = MyConst3;
+                const int32 MyConst3 = MyConst1;`
+
+                test.addTestCase(contents, []string{
+                        "Use of unresolved value: \"MyConst2\"",
+                        "Use of unresolved value: \"MyConst3\"",
+                        "Use of unresolved value: \"MyConst1\"",
+                })
+        }
+
+        ////////////////////////////////////////////////////////////
         // Execute all of the test cases.
         ////////////////////////////////////////////////////////////
         for i, c := range test.cases {
                 // Parse and resolve the mojom input.
                 descriptor := mojom.NewMojomDescriptor()
                 specifiedName := ""
                 if c.importedFrom == nil {
                         specifiedName = c.fileName
                 }
                 parser := parser.MakeParser(c.fileName, specifiedName, c.mojomContents, descriptor, c.importedFrom)
@@ skipping 931 matching lines @@
                         key := concreteValue.ValueKey()
                         if key != "TYPE_KEY:Color.BLUE" {
                                 return fmt.Errorf("%s != TYPE_KEY:Color.BLUE", key)
                         }
                         return nil
                 }
                 test.addTestCase("", contents, testFunc)
         }
 
         ////////////////////////////////////////////////////////////
+        // Test Case: A non-circular list of constant references.
+        ////////////////////////////////////////////////////////////
+        {
+                contents := `
+                const int32 MyConst1 = MyConst2;
+                const int32 MyConst2 = MyConst3;
+                const int32 MyConst3 = 42;`
+
+                testFunc := func(descriptor *mojom.MojomDescriptor) error {
+                        myConst1 := descriptor.ValuesByKey["TYPE_KEY:MyConst1"].(*mojom.UserDefinedConstant)
+                        value := myConst1.ValueRef().ResolvedConcreteValue().Value()
+                        if value != int8(42) {
+                                return fmt.Errorf("%v(%T) != 42", value, value)
+                        }
+
+                        return nil
+                }
+                test.addTestCase("", contents, testFunc)
+        }
+
+        ////////////////////////////////////////////////////////////
+        // Test Case: Circular reference of enum values
+        //
+        // NOTE: Even though we have a circular reference of enum values
+        // this case passes resolution. But the error will be detected during
+        // data computation phase when we attempt to produce integer values
+        // for the enum values. See TestEnumComputedDataError in computed_data_test.go. The reason this
+        // passes resoultion is that an enum value is a concrete value and so
+        // FIRST_VALUE has fully resolved to the concrete value MyEnum.x.
+        ////////////////////////////////////////////////////////////
+        {
+                contents := `
+                enum MyEnum {
+                        x = FIRST_VALUE,
+                        y,
+                        z
+                };
+                const MyEnum FIRST_VALUE = MyEnum.x;`
+                test.addTestCase("", contents, nil)
+        }
+
+        ////////////////////////////////////////////////////////////
         // Execute all of the test cases.
         ////////////////////////////////////////////////////////////
         for i, c := range test.cases {
                 // Parse and resolve the mojom input.
                 descriptor := mojom.NewMojomDescriptor()
                 fileName := fmt.Sprintf("file%d", i)
                 parser := parser.MakeParser(fileName, fileName, c.mojomContents, descriptor, nil)
                 parser.Parse()
                 if !parser.OK() {
                         t.Errorf("Parsing error for %s: %s", fileName, parser.GetError().Error())
                         continue
                 }
                 err := descriptor.Resolve()
                 if err != nil {
                         t.Errorf("Resolution failed for test case %d: %s", i, err.Error())
                         continue
                 }
 
                 if c.testFunc != nil {
                         if err := c.testFunc(descriptor); err != nil {
                                 t.Errorf("%s:\n%s", fileName, err.Error())
                                 continue
                         }
                 }
         }
 }