Front-end: Warn for likely missed change in default precisions.

Test/baseResults/spv.aggOps.frag.out

 spv.aggOps.frag
 Warning, version 450 is not yet complete; most version-specific features are present, but some are missing.
+WARNING: 0:4: '' : all default precisions are highp; use precision statements to quiet warning, e.g.:
+         "precision mediump int; precision highp float;" 
 
 
 Linked fragment stage:

Test/baseResults/spv.structAssignment.frag.out

 spv.structAssignment.frag
+WARNING: 0:6: '' : all default precisions are highp; use precision statements to quiet warning, e.g.:
+         "precision mediump int; precision highp float;" 
+
 
 Linked fragment stage:
 
@@ -33,6 +36,10 @@ Linked fragment stage:
                               Name 40  "samp2D"
                               Name 44  "coord"
                               Name 49  "foo"
+                              MemberDecorate 8(lunarStruct1) 0 RelaxedPrecision
+                              MemberDecorate 9(lunarStruct2) 0 RelaxedPrecision
+                              MemberDecorate 10(lunarStruct3) 1 RelaxedPrecision
+                              Decorate 16 RelaxedPrecision
                               Decorate 40(samp2D) DescriptorSet 0
                               Decorate 44(coord) RelaxedPrecision
                               Decorate 45 RelaxedPrecision

Test/baseResults/vulkan.frag.out

@@ -33,6 +33,8 @@ ERROR: 0:67: 'uniform' : no qualifiers allowed for function return
 ERROR: 0:69: 'non-opaque uniforms outside a block' : not allowed when using GLSL for Vulkan 
 ERROR: 0:73: 'texture' : no matching overloaded function found 
 ERROR: 0:74: 'imageStore' : no matching overloaded function found 
+WARNING: 0:82: '' : all default precisions are highp; use precision statements to quiet warning, e.g.:
+         "precision mediump int; precision highp float;" 
 ERROR: 0:91: 'call argument' : sampler constructor must appear at point of use 
 ERROR: 0:92: 'call argument' : sampler constructor must appear at point of use 
 ERROR: 0:93: ',' : sampler constructor must appear at point of use 

Test/spv.merge-unreachable.frag

 #version 450
+precision mediump int; precision highp float;
 layout(location=1) in highp vec4 v;
 void main (void)
 {

Test/spv.structAssignment.frag

 #version 140
 
+precision mediump int;
+
 uniform sampler2D samp2D;
 in mediump vec2 coord;
 

glslang/Include/revision.h

@@ -2,5 +2,5 @@
 // For the version, it uses the latest git tag followed by the number of commits.
 // For the date, it uses the current date (when then script is run).
 
-#define GLSLANG_REVISION "SPIRV99.1384"
-#define GLSLANG_DATE "03-Aug-2016"
+#define GLSLANG_REVISION "Overload400-PrecQual.1430"
+#define GLSLANG_DATE "23-Aug-2016"

glslang/MachineIndependent/ParseHelper.cpp

@@ -62,7 +62,12 @@ TParseContext::TParseContext(TSymbolTable& symbolTable, TIntermediate& interm, b
     linkage = new TIntermAggregate;
 
     // decide whether precision qualifiers should be ignored or respected
-    obeyPrecisionQualifiers_ = profile == EEsProfile || spvVersion.vulkan > 0;
+    if (profile == EEsProfile || spvVersion.vulkan > 0) {
+        precisionManager.respectPrecisionQualifiers();
+        if (! parsingBuiltins && language == EShLangFragment && profile != EEsProfile && spvVersion.vulkan > 0)
+            precisionManager.warnAboutDefaults();
+    }
+
     setPrecisionDefaults();
 
     globalUniformDefaults.clear();
@@ -1899,6 +1904,24 @@ TFunction* TParseContext::handleConstructorCall(const TSourceLoc& loc, const TPu
     return new TFunction(&empty, type, op);
 }
 
+// Handle seeing a precision qualifier in the grammar.
+void TParseContext::handlePrecisionQualifier(const TSourceLoc& loc, TQualifier& qualifier, TPrecisionQualifier precision)
+{
+    if (obeyPrecisionQualifiers())
+        qualifier.precision = precision;
+}
+
+// Check for messages to give on seeing a precision qualifier used in a
+// declaration in the grammar.
+void TParseContext::checkPrecisionQualifier(const TSourceLoc& loc, TPrecisionQualifier)
+{
+    if (precisionManager.shouldWarnAboutDefaults()) {
+        warn(loc, "all default precisions are highp; use precision statements to quiet warning, e.g.:\n"
+                  "         \"precision mediump int; precision highp float;\"", "", "");
+        precisionManager.defaultWarningGiven();
+    }
+}
+
 //
 // Same error message for all places assignments don't work.
 //
@@ -2904,8 +2927,11 @@ void TParseContext::setDefaultPrecision(const TSourceLoc& loc, TPublicType& publ
     if (basicType == EbtInt || basicType == EbtFloat) {
         if (publicType.isScalar()) {
             defaultPrecision[basicType] = qualifier;
-            if (basicType == EbtInt)
+            if (basicType == EbtInt) {
                 defaultPrecision[EbtUint] = qualifier;
+                precisionManager.explicitIntDefaultSeen();
+            } else
+                precisionManager.explicitFloatDefaultSeen();
 
             return;  // all is well
         }

glslang/MachineIndependent/ParseHelper.h

@@ -145,6 +145,40 @@ protected:
 };
 
 //
+// Manage the state for when to respect precision qualifiers and when to warn about
+// the defaults being different than might be expected.
+//
+class TPrecisionManager {
+public:
+    TPrecisionManager() : obey(false), warn(false), explicitIntDefault(false), explicitFloatDefault(false){ }
+    virtual ~TPrecisionManager() {}
+
+    void respectPrecisionQualifiers() { obey = true; }
+    bool respectingPrecisionQualifiers() const { return obey; }
+    bool shouldWarnAboutDefaults() const { return warn; }
+    void defaultWarningGiven() { warn = false; }
+    void warnAboutDefaults() { warn = true; }
+    void explicitIntDefaultSeen()
+    {
+        explicitIntDefault = true;
+        if (explicitFloatDefault)
+            warn = false;
+    }
+    void explicitFloatDefaultSeen()
+    {
+        explicitFloatDefault = true;
+        if (explicitIntDefault)
+            warn = false;
+    }
+
+protected:
+    bool obey;                  // respect precision qualifiers
+    bool warn;                  // need to give a warning about the defaults
+    bool explicitIntDefault;    // user set the default for int/uint
+    bool explicitFloatDefault;  // user set the default for float
+};
+
+//
 // GLSL-specific parse helper.  Should have GLSL in the name, but that's
 // too big of a change for comparing branches at the moment, and perhaps
 // impacts downstream consumers as well.
@@ -155,7 +189,7 @@ public:
                   bool forwardCompatible = false, EShMessages messages = EShMsgDefault);
     virtual ~TParseContext();
 
-    bool obeyPrecisionQualifiers() const { return obeyPrecisionQualifiers_; };
+    bool obeyPrecisionQualifiers() const { return precisionManager.respectingPrecisionQualifiers(); };
     void setPrecisionDefaults();
 
     void setLimits(const TBuiltInResource&);
@@ -212,6 +246,8 @@ public:
     void userFunctionCallCheck(const TSourceLoc&, TIntermAggregate&);
     void samplerConstructorLocationCheck(const TSourceLoc&, const char* token, TIntermNode*);
     TFunction* handleConstructorCall(const TSourceLoc&, const TPublicType&);
+    void handlePrecisionQualifier(const TSourceLoc&, TQualifier&, TPrecisionQualifier);
+    void checkPrecisionQualifier(const TSourceLoc&, TPrecisionQualifier);
 
     bool parseVectorFields(const TSourceLoc&, const TString&, int vecSize, TVectorFields&);
     void assignError(const TSourceLoc&, const char* op, TString left, TString right);
@@ -344,6 +380,7 @@ protected:
     const bool parsingBuiltins;        // true if parsing built-in symbols/functions
     static const int maxSamplerIndex = EsdNumDims * (EbtNumTypes * (2 * 2 * 2 * 2 * 2)); // see computeSamplerTypeIndex()
     TPrecisionQualifier defaultSamplerPrecision[maxSamplerIndex];
+    TPrecisionManager precisionManager;
     bool afterEOF;
     TQualifier globalBufferDefaults;
     TQualifier globalUniformDefaults;
@@ -354,7 +391,6 @@ protected:
     TIdSetType inductiveLoopIds;
     bool anyIndexLimits;
     TVector<TIntermTyped*> needsIndexLimitationChecking;
-    bool obeyPrecisionQualifiers_;
 
     //
     // Geometry shader input arrays:

glslang/MachineIndependent/glslang.y

@@ -1125,6 +1125,7 @@ single_type_qualifier
         $$ = $1;
     }
     | precision_qualifier {
+        parseContext.checkPrecisionQualifier($1.loc, $1.qualifier.precision);
         $$ = $1;
     }
     | interpolation_qualifier {
@@ -2206,20 +2207,17 @@ precision_qualifier
     : HIGH_PRECISION {
         parseContext.profileRequires($1.loc, ENoProfile, 130, 0, "highp precision qualifier");
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-        if (parseContext.obeyPrecisionQualifiers())
-            $$.qualifier.precision = EpqHigh;
+        parseContext.handlePrecisionQualifier($1.loc, $$.qualifier, EpqHigh);
     }
     | MEDIUM_PRECISION {
         parseContext.profileRequires($1.loc, ENoProfile, 130, 0, "mediump precision qualifier");
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-        if (parseContext.obeyPrecisionQualifiers())
-            $$.qualifier.precision = EpqMedium;
+        parseContext.handlePrecisionQualifier($1.loc, $$.qualifier, EpqMedium);
     }
     | LOW_PRECISION {
         parseContext.profileRequires($1.loc, ENoProfile, 130, 0, "lowp precision qualifier");
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
-        if (parseContext.obeyPrecisionQualifiers())
-            $$.qualifier.precision = EpqLow;
+        parseContext.handlePrecisionQualifier($1.loc, $$.qualifier, EpqLow);
     }
     ;