GLSL: Simplify constructor parsing

src/compiler/translator/IntermNode.cpp

@@ -304,10 +304,10 @@ TIntermAggregate *TIntermAggregate::CreateBuiltInFunctionCall(const TFunction &f
 }
 
 TIntermAggregate *TIntermAggregate::CreateConstructor(const TType &type,
-                                                      TOperator op,
                                                       TIntermSequence *arguments)
 {
-    TIntermAggregate *constructorNode = new TIntermAggregate(type, op, arguments);
+    TIntermAggregate *constructorNode =
+        new TIntermAggregate(type, sh::TypeToConstructorOperator(type), arguments);
     ASSERT(constructorNode->isConstructor());
     return constructorNode;
 }
@@ -630,8 +630,7 @@ TIntermTyped *TIntermTyped::CreateZero(const TType &type)
         }
     }
 
-    return TIntermAggregate::CreateConstructor(constType, sh::TypeToConstructorOperator(type),
-                                               arguments);
+    return TIntermAggregate::CreateConstructor(constType, arguments);
 }
 
 // static
@@ -777,9 +776,7 @@ bool TIntermOperator::isMultiplication() const
     }
 }
 
-//
-// returns true if the operator is for one of the constructors
-//
+// Returns true if the operator is for one of the constructors.
 bool TIntermOperator::isConstructor() const
 {
     switch (mOp)
@@ -812,6 +809,8 @@ bool TIntermOperator::isConstructor() const
         case EOpConstructStruct:
             return true;
         default:
+            // EOpConstruct is not supposed to be used in the AST.
+            ASSERT(mOp != EOpConstruct);
             return false;
     }
 }

src/compiler/translator/IntermNode.h

@@ -604,7 +604,6 @@ class TIntermAggregate : public TIntermOperator, public TIntermAggregateBase
     static TIntermAggregate *CreateBuiltInFunctionCall(const TFunction &func,
                                                        TIntermSequence *arguments);
     static TIntermAggregate *CreateConstructor(const TType &type,
-                                               TOperator op,
                                                TIntermSequence *arguments);
     static TIntermAggregate *Create(const TType &type, TOperator op, TIntermSequence *arguments);
     ~TIntermAggregate() {}

src/compiler/translator/Operator.h

@@ -205,6 +205,10 @@ enum TOperator
     // Constructors
     //
 
+    // Used by ParseContext to denote any constructor.
+    EOpConstruct,
+
+    // In the AST, constructors are stored using the below more specific op codes.
     EOpConstructInt,
     EOpConstructUInt,
     EOpConstructBool,

src/compiler/translator/ParseContext.h

@@ -113,7 +113,6 @@ class TParseContext : angle::NonCopyable
     bool checkIsAtGlobalLevel(const TSourceLoc &line, const char *token);
     bool checkConstructorArguments(const TSourceLoc &line,
                                    const TIntermSequence *arguments,
-                                   TOperator op,
                                    const TType &type);
 
     // Returns a sanitized array size to use (the size is at least 1).
@@ -415,7 +414,6 @@ class TParseContext : angle::NonCopyable
                             TIntermNode *thisNode,
                             const TSourceLoc &loc);
     TIntermTyped *addConstructor(TIntermSequence *arguments,
-                                 TOperator op,
                                  TType type,
                                  const TSourceLoc &line);
     TIntermTyped *addNonConstructorFunctionCall(TFunction *fnCall,

src/compiler/translator/RemoveDynamicIndexing.cpp

@@ -110,7 +110,7 @@ TIntermTyped *EnsureSignedInt(TIntermTyped *node)
 
     TIntermSequence *arguments = new TIntermSequence();
     arguments->push_back(node);
-    return TIntermAggregate::CreateConstructor(TType(EbtInt), EOpConstructInt, arguments);
+    return TIntermAggregate::CreateConstructor(TType(EbtInt), arguments);
 }
 
 TType GetFieldType(const TType &indexedType)

src/compiler/translator/RewriteTexelFetchOffset.cpp

@@ -110,7 +110,7 @@ bool Traverser::visitAggregate(Visit visit, TIntermAggregate *node)
         TIntermTyped *zeroNode = TIntermTyped::CreateZero(TType(EbtInt));
         constructOffsetIvecArguments->push_back(zeroNode);
 
-        offsetNode = TIntermAggregate::CreateConstructor(texCoordNode->getType(), EOpConstructIVec3,
+        offsetNode = TIntermAggregate::CreateConstructor(texCoordNode->getType(),
                                                          constructOffsetIvecArguments);
         offsetNode->setLine(texCoordNode->getLine());
     }

src/compiler/translator/Types.cpp

@@ -125,6 +125,8 @@ TType::TType(const TPublicType &p)
       interfaceBlock(0),
       structure(0)
 {
+    ASSERT(primarySize <= 4);
+    ASSERT(secondarySize <= 4);
     if (p.getUserDef())
         structure = p.getUserDef()->getStruct();
 }
@@ -134,6 +136,21 @@ bool TStructure::equals(const TStructure &other) const
     return (uniqueId() == other.uniqueId());
 }
 
+bool TType::canBeConstructed() const
+{
+    switch (type)
+    {
+        case EbtFloat:
+        case EbtInt:
+        case EbtUInt:
+        case EbtBool:
+        case EbtStruct:
+            return true;
+        default:
+            return false;
+    }
+}
+
 const char *TType::getBuiltInTypeNameString() const
 {
     if (isMatrix())

src/compiler/translator/Types.h

@@ -318,6 +318,7 @@ class TType
     {
         if (primarySize != ps)
         {
+            ASSERT(ps <= 4);
             primarySize = ps;
             invalidateMangledName();
         }
@@ -326,6 +327,7 @@ class TType
     {
         if (secondarySize != ss)
         {
+            ASSERT(ss <= 4);
             secondarySize = ss;
             invalidateMangledName();
         }
@@ -377,6 +379,8 @@ class TType
     bool isScalarFloat() const { return isScalar() && type == EbtFloat; }
     bool isScalarInt() const { return isScalar() && (type == EbtInt || type == EbtUInt); }
 
+    bool canBeConstructed() const;
+
     TStructure *getStruct() const { return structure; }
     void setStruct(TStructure *s)
     {