Always emit precision in shader variable declarations.

src/common/version.h

 #define MAJOR_VERSION 0
 #define MINOR_VERSION 0
 #define BUILD_VERSION 0
-#define BUILD_REVISION 694
+#define BUILD_REVISION 695
 
 #define STRINGIFY(x) #x
 #define MACRO_STRINGIFY(x) STRINGIFY(x)

src/compiler/Compiler.cpp

@@ -18,7 +18,9 @@ bool InitializeSymbolTable(
 {
     TIntermediate intermediate(infoSink);
     TExtensionBehavior extBehavior;
-    TParseContext parseContext(symbolTable, extBehavior, intermediate, type, spec, 0, NULL, infoSink);
+    // The builtins deliberately don't specify precisions for the function
+    // arguments and return types. For that reason we don't try to check them.
+    TParseContext parseContext(symbolTable, extBehavior, intermediate, type, spec, 0, false, NULL, infoSink);
 
     GlobalParseContext = &parseContext;
 
@@ -127,7 +129,7 @@ bool TCompiler::compile(const char* const shaderStrings[],
 
     TIntermediate intermediate(infoSink);
     TParseContext parseContext(symbolTable, extensionBehavior, intermediate,
-                               shaderType, shaderSpec, compileOptions,
+                               shaderType, shaderSpec, compileOptions, true,
                                sourcePath, infoSink);
     GlobalParseContext = &parseContext;
 

src/compiler/ParseHelper.cpp

@@ -261,6 +261,8 @@ void TParseContext::binaryOpError(int line, const char* op, TString left, TStrin
 }
 
 bool TParseContext::precisionErrorCheck(int line, TPrecision precision, TBasicType type){
+    if (!checksPrecisionErrors)
+        return false;
     switch( type ){
     case EbtFloat:
         if( precision == EbpUndefined ){

src/compiler/ParseHelper.h

@@ -30,8 +30,8 @@ struct TPragma {
 // they can be passed to the parser without needing a global.
 //
 struct TParseContext {
-    TParseContext(TSymbolTable& symt, TExtensionBehavior& ext, TIntermediate& interm, ShShaderType type, ShShaderSpec spec, int options, const char* sourcePath, TInfoSink& is) :
-            intermediate(interm), symbolTable(symt), extensionBehavior(ext), infoSink(is), shaderType(type), shaderSpec(spec), compileOptions(options), sourcePath(sourcePath), treeRoot(0),
+    TParseContext(TSymbolTable& symt, TExtensionBehavior& ext, TIntermediate& interm, ShShaderType type, ShShaderSpec spec, int options, bool checksPrecErrors, const char* sourcePath, TInfoSink& is) :
+            intermediate(interm), symbolTable(symt), extensionBehavior(ext), infoSink(is), shaderType(type), shaderSpec(spec), compileOptions(options), checksPrecisionErrors(checksPrecErrors), sourcePath(sourcePath), treeRoot(0),
             recoveredFromError(false), numErrors(0), lexAfterType(false), loopNestingLevel(0),
             inTypeParen(false), scanner(NULL), contextPragma(true, false) {  }
     TIntermediate& intermediate; // to hold and build a parse tree
@@ -50,6 +50,7 @@ struct TParseContext {
     bool inTypeParen;            // true if in parentheses, looking only for an identifier
     const TType* currentFunctionType;  // the return type of the function that's currently being parsed
     bool functionReturnsValue;   // true if a non-void function has a return
+    bool checksPrecisionErrors;  // true if an error will be generated when a variable is declared without precision, explicit or implicit.
 
     void error(TSourceLoc loc, const char *reason, const char* token,
                const char* extraInfoFormat, ...);

src/compiler/TranslatorESSL.cpp

@@ -18,18 +18,6 @@ void TranslatorESSL::translate(TIntermNode* root) {
     // Write built-in extension behaviors.
     writeExtensionBehavior();
 
-    // FIXME(zmo): no need to emit default precision if all variables emit
-    // their own precision.
-    // http://code.google.com/p/angleproject/issues/detail?id=168
-    if (this->getShaderType() == SH_FRAGMENT_SHADER) {
-        // Write default float precision.
-        sink << "#if defined(GL_FRAGMENT_PRECISION_HIGH)\n"
-             << "precision highp float;\n"
-             << "#else\n"
-             << "precision mediump float;\n"
-             << "#endif\n";
-    }
-
     // Write translated shader.
     TOutputESSL outputESSL(sink);
     root->traverse(&outputESSL);

src/compiler/glslang.y

@@ -591,17 +591,10 @@ function_call_header
 // Grammar Note:  Constructors look like functions, but are recognized as types.
 
 function_identifier
-    : type_specifier {
+    : type_specifier_nonarray {
         //
         // Constructor
         //
-        if ($1.array) {
-            // Constructors for arrays are not allowed.
-            context->error($1.line, "cannot construct this type", "array", "");
-            context->recover();
-            $1.setArray(false);
-        }
-
         TOperator op = EOpNull;
         if ($1.userDef) {
             op = EOpConstructStruct;
@@ -1176,13 +1169,6 @@ parameter_type_specifier
 init_declarator_list
     : single_declaration {
         $$ = $1;
-        
-        if ($$.type.precision == EbpUndefined) {
-            $$.type.precision = context->symbolTable.getDefaultPrecision($1.type.type);
-            if (context->precisionErrorCheck($1.line, $$.type.precision, $1.type.type)) {
-                context->recover();
-            }
-        }
     }
     | init_declarator_list COMMA IDENTIFIER {
         TIntermSymbol* symbol = context->intermediate.addSymbol(0, *$3.string, TType($1.type), $3.line);
@@ -1490,6 +1476,13 @@ type_qualifier
 type_specifier
     : type_specifier_no_prec {
         $$ = $1;
+
+        if ($$.precision == EbpUndefined) {
+            $$.precision = context->symbolTable.getDefaultPrecision($1.type);
+            if (context->precisionErrorCheck($1.line, $$.precision, $1.type)) {
+                context->recover();
+            }
+        }
     }
     | precision_qualifier type_specifier_no_prec {
         $$ = $2;
@@ -1693,6 +1686,7 @@ struct_declaration
             type->setBasicType($1.type);
             type->setNominalSize($1.size);
             type->setMatrix($1.matrix);
+            type->setPrecision($1.precision);
 
             // don't allow arrays of arrays
             if (type->isArray()) {