New Mojom parser: Don't allow enum variables to be assigned int values.

mojom/mojom_parser/mojom/types.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 mojom
 
 import (
         "fmt"
         "math"
         "mojom/mojom_parser/lexer"
@@ skipping 762 matching lines @@
         case BuiltInConstantValue:
                 return false
         case *EnumValue:
                 return ref.resolvedType == assignedValue.EnumType()
         default:
                 panic(fmt.Sprintf("Unexpected type %T.", assignedValue))
         }
 }
 
 func (t *UserTypeRef) MarkTypeCompatible(assignment LiteralAssignment) bool {
-        switch assignment.assignedValue.LiteralValueType() {
-        case SimpleTypeDouble, SimpleTypeFloat, SimpleTypeBool:
-                return false
-        case StringLiteralType:
-                if !assignment.assignedValue.IsDefault() {
-                        return false
-                }
-        }
-
+        // Just mark the assignment attempt and return true. We will validate it
+        // during the validation phase.
         t.literalAssignment = &assignment
         return true
 }
 
 func (ref *UserTypeRef) validateAfterResolution() error {
         var file *MojomFile = nil
         if ref.scope != nil && ref.scope.file != nil {
                 file = ref.scope.file
         }
         if ref.resolvedType.Kind() != UserDefinedTypeKindEnum {
@@ skipping 145 matching lines @@
                                         v.identifier, concreteValue)
                                 message = UserErrorMessage(v.scope.file, v.token, message)
                                 return fmt.Errorf(message)
                         }
                 case BuiltInConstantValue:
                         message := fmt.Sprintf("Illegal assignment: %s cannot be used as an enum value initializer.", v.identifier)
                         message = UserErrorMessage(v.scope.file, v.token, message)
                         return fmt.Errorf(message)
                 case *EnumValue:
                         // An EnumValue is being used as an EnumValue initializer.
-                        // Below we will check that the two EnumTypes match.
+                        // We will only check that the two EnumTypes match.
                         // In ComputeEnumValueIntegers() in computed_data.go we will further validate.
+                        if !v.assigneeSpec.Type.IsAssignmentCompatible(v.resolvedConcreteValue) {
+                                var message string
+                                switch v.resolvedDeclaredValue.(type) {
+                                case *EnumValue:
+                                        // An enum value is being used directly as an initializer.
+                                        message = fmt.Sprintf("Illegal assignment: The enum value %s of type %s may not be used as an initializer for %s of type %s.",
+                                                v.identifier, concreteValue.enumType.fullyQualifiedName, v.assigneeSpec.Name, v.assigneeSpec.Type.TypeName())
+                                default:
+                                        // A user-defined constant whose value is an enum value is being used as an initializer.
+                                        message = fmt.Sprintf("Illegal assignment: %s with the value %v may not be used as an initializer for %s of type %s.",
+                                                v.identifier, concreteValue.fullyQualifiedName, v.assigneeSpec.Name, v.assigneeSpec.Type.TypeName())
+                                }
+                                return fmt.Errorf(UserErrorMessage(v.scope.file, v.token, message))
+                        }
                 default:
                         panic(fmt.Sprintf("Unexpected type %T", concreteValue))
                 }
-
+                return nil
         }
 
         if !v.assigneeSpec.Type.IsAssignmentCompatible(v.resolvedConcreteValue) {
                 var message string
                 switch assigneeType := v.assigneeSpec.Type.(type) {
                 case SimpleType, StringType, *UserTypeRef:
                         switch concreteValue := v.resolvedConcreteValue.(type) {
                         case LiteralValue:
                                 // A user-defined constant whose value is a literal value is being assigned to a variable.
                                 message = fmt.Sprintf("Illegal assignment: %s with the value %v of type %s may not be assigned to %s of type %s.",
                                         v.identifier, concreteValue, concreteValue.LiteralValueType(), v.assigneeSpec.Name, assigneeType.TypeName())
                         case BuiltInConstantValue:
                                 switch v.resolvedDeclaredValue.(type) {
                                 case BuiltInConstantValue:
                                         // A built-in float constant is being assigned directly to a variable.
                                         message = fmt.Sprintf("Illegal assignment: %s may not be assigned to %s of type %s.",
                                                 v.identifier, v.assigneeSpec.Name, assigneeType.TypeName())
                                 default:
                                         // A user-defined constant whose value is a built-in float constant is being assigned to a variable.
                                         message = fmt.Sprintf("Illegal assignment: %s with the value %v may not be assigned to %s of type %s.",
                                                 v.identifier, concreteValue, v.assigneeSpec.Name, assigneeType.TypeName())
                                 }
                         case *EnumValue:
                                 switch v.resolvedDeclaredValue.(type) {
                                 case *EnumValue:
                                         // An enum value is being assigned directly to a variable.
-                                        message = "Illegal assignment: The enum value %s of type %s may not be assigned to %s of type %s."
-                                        if v.usedAsEnumValueInitializer {
-                                                // An enum value is being used directly as an initializer.
-                                                message = "Illegal assignment: The enum value %s of type %s may not be used as an initializer for %s of type %s."
-                                        }
-                                        message = fmt.Sprintf(message, v.identifier, concreteValue.enumType.fullyQualifiedName, v.assigneeSpec.Name, assigneeType.TypeName())
+                                        message = fmt.Sprintf("Illegal assignment: The enum value %s of type %s may not be assigned to %s of type %s.",
+                                                v.identifier, concreteValue.enumType.fullyQualifiedName, v.assigneeSpec.Name, assigneeType.TypeName())
                                 default:
                                         // A user-defined constant whose value is an enum value is being assigned to a variable.
                                         message = "Illegal assignment: %s with the value %v may not be assigned to %s of type %s."
                                         if v.usedAsEnumValueInitializer {
-                                                // A user-defined constant whose value is an enum valu is being used as an initializer.
+                                                // A user-defined constant whose value is an enum value is being used as an initializer.
                                                 message = "Illegal assignment: %s with the value %v may not be used as an initializer for %s of type %s."
                                         }
                                         message = fmt.Sprintf(message, v.identifier, concreteValue.fullyQualifiedName, v.assigneeSpec.Name, assigneeType.TypeName())
                                 }
                         default:
                                 panic(fmt.Sprintf("Unexpected type %T", concreteValue))
                         }
                 default:
                         panic(fmt.Sprintf("Unexpected type %T", assigneeType))
                 }
@@ skipping 204 matching lines @@
         default:
                 panic(fmt.Sprintf("Unknown LiteralAssignmentKind %d", k))
         }
 }
 
 type LiteralAssignment struct {
         assignedValue LiteralValue
         variableName  string
         kind          LiteralAssignmentKind
 }