Cycles: fix compilation of OSL shaders following API change

The names of the parameters are based on those of those of the sockets, so they also need to be updated. This was forgotten about in the previous commit (rBa284e559b90e).

Ref T82561.

12 files changed, 134 insertions, 134 deletions

diff --git a/intern/cycles/kernel/shaders/node_clamp.osl b/intern/cycles/kernel/shaders/node_clamp.osl
index ce9392a0d98..22a1cac7114 100644
--- a/intern/cycles/kernel/shaders/node_clamp.osl
+++ b/intern/cycles/kernel/shaders/node_clamp.osl
@@ -16,11 +16,11 @@
 
 #include "stdcycles.h"
 
-shader node_clamp(string type = "minmax",
+shader node_clamp(string clamp_type = "minmax",
                   float Value = 1.0,
                   float Min = 0.0,
                   float Max = 1.0,
                   output float Result = 0.0)
 {
-  Result = (type == "range" && (Min > Max)) ? clamp(Value, Max, Min) : clamp(Value, Min, Max);
+  Result = (clamp_type == "range" && (Min > Max)) ? clamp(Value, Max, Min) : clamp(Value, Min, Max);
 }
diff --git a/intern/cycles/kernel/shaders/node_gradient_texture.osl b/intern/cycles/kernel/shaders/node_gradient_texture.osl
index e9acebc0572..c7faee0d022 100644
--- a/intern/cycles/kernel/shaders/node_gradient_texture.osl
+++ b/intern/cycles/kernel/shaders/node_gradient_texture.osl
@@ -62,7 +62,7 @@ float gradient(point p, string type)
 shader node_gradient_texture(
     int use_mapping = 0,
     matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
-    string type = "linear",
+    string gradient_type = "linear",
     point Vector = P,
     output float Fac = 0.0,
     output color Color = 0.0)
@@ -72,6 +72,6 @@ shader node_gradient_texture(
   if (use_mapping)
     p = transform(mapping, p);
 
-  Fac = gradient(p, type);
+  Fac = gradient(p, gradient_type);
   Color = color(Fac, Fac, Fac);
 }
diff --git a/intern/cycles/kernel/shaders/node_map_range.osl b/intern/cycles/kernel/shaders/node_map_range.osl
index 1c49027e6dd..2fcc664a80e 100644
--- a/intern/cycles/kernel/shaders/node_map_range.osl
+++ b/intern/cycles/kernel/shaders/node_map_range.osl
@@ -27,7 +27,7 @@ float smootherstep(float edge0, float edge1, float x)
   return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
 }
 
-shader node_map_range(string type = "linear",
+shader node_map_range(string range_type = "linear",
                       float Value = 1.0,
                       float FromMin = 0.0,
                       float FromMax = 1.0,
@@ -38,15 +38,15 @@ shader node_map_range(string type = "linear",
 {
   if (FromMax != FromMin) {
     float Factor = Value;
-    if (type == "stepped") {
+    if (range_type == "stepped") {
       Factor = (Value - FromMin) / (FromMax - FromMin);
       Factor = (Steps > 0) ? floor(Factor * (Steps + 1.0)) / Steps : 0.0;
     }
-    else if (type == "smoothstep") {
+    else if (range_type == "smoothstep") {
       Factor = (FromMin > FromMax) ? 1.0 - smoothstep(FromMax, FromMin, Value) :
                                      smoothstep(FromMin, FromMax, Value);
     }
-    else if (type == "smootherstep") {
+    else if (range_type == "smootherstep") {
       Factor = (FromMin > FromMax) ? 1.0 - smootherstep(FromMax, FromMin, Value) :
                                      smootherstep(FromMin, FromMax, Value);
     }
diff --git a/intern/cycles/kernel/shaders/node_mapping.osl b/intern/cycles/kernel/shaders/node_mapping.osl
index 8d204999630..131640685bc 100644
--- a/intern/cycles/kernel/shaders/node_mapping.osl
+++ b/intern/cycles/kernel/shaders/node_mapping.osl
@@ -47,24 +47,24 @@ matrix euler_to_mat(point euler)
   return mat;
 }
 
-shader node_mapping(string type = "point",
+shader node_mapping(string mapping_type = "point",
                     point VectorIn = point(0.0, 0.0, 0.0),
                     point Location = point(0.0, 0.0, 0.0),
                     point Rotation = point(0.0, 0.0, 0.0),
                     point Scale = point(1.0, 1.0, 1.0),
                     output point VectorOut = point(0.0, 0.0, 0.0))
 {
-  if (type == "point") {
+  if (mapping_type == "point") {
     VectorOut = transform(euler_to_mat(Rotation), (VectorIn * Scale)) + Location;
   }
-  else if (type == "texture") {
+  else if (mapping_type == "texture") {
     VectorOut = safe_divide(transform(transpose(euler_to_mat(Rotation)), (VectorIn - Location)),
                             Scale);
   }
-  else if (type == "vector") {
+  else if (mapping_type == "vector") {
     VectorOut = transform(euler_to_mat(Rotation), (VectorIn * Scale));
   }
-  else if (type == "normal") {
+  else if (mapping_type == "normal") {
     VectorOut = normalize((vector)transform(euler_to_mat(Rotation), safe_divide(VectorIn, Scale)));
   }
   else {
diff --git a/intern/cycles/kernel/shaders/node_math.osl b/intern/cycles/kernel/shaders/node_math.osl
index dbaa7ccb60e..66884610561 100644
--- a/intern/cycles/kernel/shaders/node_math.osl
+++ b/intern/cycles/kernel/shaders/node_math.osl
@@ -18,91 +18,91 @@
 #include "stdcycles.h"
 
 /* OSL asin, acos, and pow functions are safe by default. */
-shader node_math(string type = "add",
+shader node_math(string math_type = "add",
                  float Value1 = 0.5,
                  float Value2 = 0.5,
                  float Value3 = 0.5,
                  output float Value = 0.0)
 {
-  if (type == "add")
+  if (math_type == "add")
     Value = Value1 + Value2;
-  else if (type == "subtract")
+  else if (math_type == "subtract")
     Value = Value1 - Value2;
-  else if (type == "multiply")
+  else if (math_type == "multiply")
     Value = Value1 * Value2;
-  else if (type == "divide")
+  else if (math_type == "divide")
     Value = safe_divide(Value1, Value2);
-  else if (type == "power")
+  else if (math_type == "power")
     Value = pow(Value1, Value2);
-  else if (type == "logarithm")
+  else if (math_type == "logarithm")
     Value = safe_log(Value1, Value2);
-  else if (type == "sqrt")
+  else if (math_type == "sqrt")
     Value = safe_sqrt(Value1);
-  else if (type == "inversesqrt")
+  else if (math_type == "inversesqrt")
     Value = inversesqrt(Value1);
-  else if (type == "absolute")
+  else if (math_type == "absolute")
     Value = fabs(Value1);
-  else if (type == "radians")
+  else if (math_type == "radians")
     Value = radians(Value1);
-  else if (type == "degrees")
+  else if (math_type == "degrees")
     Value = degrees(Value1);
-  else if (type == "minimum")
+  else if (math_type == "minimum")
     Value = min(Value1, Value2);
-  else if (type == "maximum")
+  else if (math_type == "maximum")
     Value = max(Value1, Value2);
-  else if (type == "less_than")
+  else if (math_type == "less_than")
     Value = Value1 < Value2;
-  else if (type == "greater_than")
+  else if (math_type == "greater_than")
     Value = Value1 > Value2;
-  else if (type == "round")
+  else if (math_type == "round")
     Value = floor(Value1 + 0.5);
-  else if (type == "floor")
+  else if (math_type == "floor")
     Value = floor(Value1);
-  else if (type == "ceil")
+  else if (math_type == "ceil")
     Value = ceil(Value1);
-  else if (type == "fraction")
+  else if (math_type == "fraction")
     Value = Value1 - floor(Value1);
-  else if (type == "modulo")
+  else if (math_type == "modulo")
     Value = safe_modulo(Value1, Value2);
-  else if (type == "trunc")
+  else if (math_type == "trunc")
     Value = trunc(Value1);
-  else if (type == "snap")
+  else if (math_type == "snap")
     Value = floor(safe_divide(Value1, Value2)) * Value2;
-  else if (type == "wrap")
+  else if (math_type == "wrap")
     Value = wrap(Value1, Value2, Value3);
-  else if (type == "pingpong")
+  else if (math_type == "pingpong")
     Value = pingpong(Value1, Value2);
-  else if (type == "sine")
+  else if (math_type == "sine")
     Value = sin(Value1);
-  else if (type == "cosine")
+  else if (math_type == "cosine")
     Value = cos(Value1);
-  else if (type == "tangent")
+  else if (math_type == "tangent")
     Value = tan(Value1);
-  else if (type == "sinh")
+  else if (math_type == "sinh")
     Value = sinh(Value1);
-  else if (type == "cosh")
+  else if (math_type == "cosh")
     Value = cosh(Value1);
-  else if (type == "tanh")
+  else if (math_type == "tanh")
     Value = tanh(Value1);
-  else if (type == "arcsine")
+  else if (math_type == "arcsine")
     Value = asin(Value1);
-  else if (type == "arccosine")
+  else if (math_type == "arccosine")
     Value = acos(Value1);
-  else if (type == "arctangent")
+  else if (math_type == "arctangent")
     Value = atan(Value1);
-  else if (type == "arctan2")
+  else if (math_type == "arctan2")
     Value = atan2(Value1, Value2);
-  else if (type == "sign")
+  else if (math_type == "sign")
     Value = sign(Value1);
-  else if (type == "exponent")
+  else if (math_type == "exponent")
     Value = exp(Value1);
-  else if (type == "compare")
+  else if (math_type == "compare")
     Value = ((Value1 == Value2) || (abs(Value1 - Value2) <= max(Value3, 1e-5))) ? 1.0 : 0.0;
-  else if (type == "multiply_add")
+  else if (math_type == "multiply_add")
     Value = Value1 * Value2 + Value3;
-  else if (type == "smoothmin")
+  else if (math_type == "smoothmin")
     Value = smoothmin(Value1, Value2, Value3);
-  else if (type == "smoothmax")
+  else if (math_type == "smoothmax")
     Value = -(smoothmin(-Value1, -Value2, Value3));
   else
     warning("%s", "Unknown math operator!");
diff --git a/intern/cycles/kernel/shaders/node_mix.osl b/intern/cycles/kernel/shaders/node_mix.osl
index a13b4bb7b96..dcd9f014f3e 100644
--- a/intern/cycles/kernel/shaders/node_mix.osl
+++ b/intern/cycles/kernel/shaders/node_mix.osl
@@ -279,7 +279,7 @@ color node_mix_clamp(color col)
   return outcol;
 }
 
-shader node_mix(string type = "mix",
+shader node_mix(string mix_type = "mix",
                 int use_clamp = 0,
                 float Fac = 0.5,
                 color Color1 = 0.0,
@@ -288,41 +288,41 @@ shader node_mix(string type = "mix",
 {
   float t = clamp(Fac, 0.0, 1.0);
 
-  if (type == "mix")
+  if (mix_type == "mix")
     Color = node_mix_blend(t, Color1, Color2);
-  if (type == "add")
+  if (mix_type == "add")
     Color = node_mix_add(t, Color1, Color2);
-  if (type == "multiply")
+  if (mix_type == "multiply")
     Color = node_mix_mul(t, Color1, Color2);
-  if (type == "screen")
+  if (mix_type == "screen")
     Color = node_mix_screen(t, Color1, Color2);
-  if (type == "overlay")
+  if (mix_type == "overlay")
     Color = node_mix_overlay(t, Color1, Color2);
-  if (type == "subtract")
+  if (mix_type == "subtract")
     Color = node_mix_sub(t, Color1, Color2);
-  if (type == "divide")
+  if (mix_type == "divide")
     Color = node_mix_div(t, Color1, Color2);
-  if (type == "difference")
+  if (mix_type == "difference")
     Color = node_mix_diff(t, Color1, Color2);
-  if (type == "darken")
+  if (mix_type == "darken")
     Color = node_mix_dark(t, Color1, Color2);
-  if (type == "lighten")
+  if (mix_type == "lighten")
     Color = node_mix_light(t, Color1, Color2);
-  if (type == "dodge")
+  if (mix_type == "dodge")
     Color = node_mix_dodge(t, Color1, Color2);
-  if (type == "burn")
+  if (mix_type == "burn")
     Color = node_mix_burn(t, Color1, Color2);
-  if (type == "hue")
+  if (mix_type == "hue")
     Color = node_mix_hue(t, Color1, Color2);
-  if (type == "saturation")
+  if (mix_type == "saturation")
     Color = node_mix_sat(t, Color1, Color2);
-  if (type == "value")
+  if (mix_type == "value")
     Color = node_mix_val(t, Color1, Color2);
-  if (type == "color")
+  if (mix_type == "color")
     Color = node_mix_color(t, Color1, Color2);
-  if (type == "soft_light")
+  if (mix_type == "soft_light")
     Color = node_mix_soft(t, Color1, Color2);
-  if (type == "linear_light")
+  if (mix_type == "linear_light")
     Color = node_mix_linear(t, Color1, Color2);
 
   if (use_clamp)
diff --git a/intern/cycles/kernel/shaders/node_musgrave_texture.osl b/intern/cycles/kernel/shaders/node_musgrave_texture.osl
index d03b84c1ab4..0e71ce74c29 100644
--- a/intern/cycles/kernel/shaders/node_musgrave_texture.osl
+++ b/intern/cycles/kernel/shaders/node_musgrave_texture.osl
@@ -684,7 +684,7 @@ float noise_musgrave_ridged_multi_fractal_4d(
 shader node_musgrave_texture(
     int use_mapping = 0,
     matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
-    string type = "fBM",
+    string musgrave_type = "fBM",
     string dimensions = "3D",
     point Vector = P,
     float W = 0.0,
@@ -707,21 +707,21 @@ shader node_musgrave_texture(
 
   if (dimensions == "1D") {
     float p = W * Scale;
-    if (type == "multifractal") {
+    if (musgrave_type == "multifractal") {
       Fac = noise_musgrave_multi_fractal_1d(p, dimension, lacunarity, octaves);
     }
-    else if (type == "fBM") {
+    else if (musgrave_type == "fBM") {
       Fac = noise_musgrave_fBm_1d(p, dimension, lacunarity, octaves);
     }
-    else if (type == "hybrid_multifractal") {
+    else if (musgrave_type == "hybrid_multifractal") {
       Fac = noise_musgrave_hybrid_multi_fractal_1d(
           p, dimension, lacunarity, octaves, Offset, Gain);
     }
-    else if (type == "ridged_multifractal") {
+    else if (musgrave_type == "ridged_multifractal") {
       Fac = noise_musgrave_ridged_multi_fractal_1d(
           p, dimension, lacunarity, octaves, Offset, Gain);
     }
-    else if (type == "hetero_terrain") {
+    else if (musgrave_type == "hetero_terrain") {
       Fac = noise_musgrave_hetero_terrain_1d(p, dimension, lacunarity, octaves, Offset);
     }
     else {
@@ -730,21 +730,21 @@ shader node_musgrave_texture(
   }
   else if (dimensions == "2D") {
     vector2 p = vector2(s[0], s[1]) * Scale;
-    if (type == "multifractal") {
+    if (musgrave_type == "multifractal") {
       Fac = noise_musgrave_multi_fractal_2d(p, dimension, lacunarity, octaves);
     }
-    else if (type == "fBM") {
+    else if (musgrave_type == "fBM") {
       Fac = noise_musgrave_fBm_2d(p, dimension, lacunarity, octaves);
     }
-    else if (type == "hybrid_multifractal") {
+    else if (musgrave_type == "hybrid_multifractal") {
       Fac = noise_musgrave_hybrid_multi_fractal_2d(
           p, dimension, lacunarity, octaves, Offset, Gain);
     }
-    else if (type == "ridged_multifractal") {
+    else if (musgrave_type == "ridged_multifractal") {
       Fac = noise_musgrave_ridged_multi_fractal_2d(
           p, dimension, lacunarity, octaves, Offset, Gain);
     }
-    else if (type == "hetero_terrain") {
+    else if (musgrave_type == "hetero_terrain") {
       Fac = noise_musgrave_hetero_terrain_2d(p, dimension, lacunarity, octaves, Offset);
     }
     else {
@@ -753,21 +753,21 @@ shader node_musgrave_texture(
   }
   else if (dimensions == "3D") {
     vector3 p = s * Scale;
-    if (type == "multifractal") {
+    if (musgrave_type == "multifractal") {
       Fac = noise_musgrave_multi_fractal_3d(p, dimension, lacunarity, octaves);
     }
-    else if (type == "fBM") {
+    else if (musgrave_type == "fBM") {
       Fac = noise_musgrave_fBm_3d(p, dimension, lacunarity, octaves);
     }
-    else if (type == "hybrid_multifractal") {
+    else if (musgrave_type == "hybrid_multifractal") {
       Fac = noise_musgrave_hybrid_multi_fractal_3d(
           p, dimension, lacunarity, octaves, Offset, Gain);
     }
-    else if (type == "ridged_multifractal") {
+    else if (musgrave_type == "ridged_multifractal") {
       Fac = noise_musgrave_ridged_multi_fractal_3d(
           p, dimension, lacunarity, octaves, Offset, Gain);
     }
-    else if (type == "hetero_terrain") {
+    else if (musgrave_type == "hetero_terrain") {
       Fac = noise_musgrave_hetero_terrain_3d(p, dimension, lacunarity, octaves, Offset);
     }
     else {
@@ -776,21 +776,21 @@ shader node_musgrave_texture(
   }
   else if (dimensions == "4D") {
     vector4 p = vector4(s[0], s[1], s[2], W) * Scale;
-    if (type == "multifractal") {
+    if (musgrave_type == "multifractal") {
       Fac = noise_musgrave_multi_fractal_4d(p, dimension, lacunarity, octaves);
     }
-    else if (type == "fBM") {
+    else if (musgrave_type == "fBM") {
       Fac = noise_musgrave_fBm_4d(p, dimension, lacunarity, octaves);
     }
-    else if (type == "hybrid_multifractal") {
+    else if (musgrave_type == "hybrid_multifractal") {
       Fac = noise_musgrave_hybrid_multi_fractal_4d(
           p, dimension, lacunarity, octaves, Offset, Gain);
     }
-    else if (type == "ridged_multifractal") {
+    else if (musgrave_type == "ridged_multifractal") {
       Fac = noise_musgrave_ridged_multi_fractal_4d(
           p, dimension, lacunarity, octaves, Offset, Gain);
     }
-    else if (type == "hetero_terrain") {
+    else if (musgrave_type == "hetero_terrain") {
       Fac = noise_musgrave_hetero_terrain_4d(p, dimension, lacunarity, octaves, Offset);
     }
     else {
diff --git a/intern/cycles/kernel/shaders/node_sky_texture.osl b/intern/cycles/kernel/shaders/node_sky_texture.osl
index a12e7a9dc17..43d7bd36973 100644
--- a/intern/cycles/kernel/shaders/node_sky_texture.osl
+++ b/intern/cycles/kernel/shaders/node_sky_texture.osl
@@ -212,7 +212,7 @@ shader node_sky_texture(
     int use_mapping = 0,
     matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
     vector Vector = P,
-    string type = "hosek_wilkie",
+    string sky_type = "hosek_wilkie",
     float theta = 0.0,
     float phi = 0.0,
     string filename = "",
@@ -228,10 +228,10 @@ shader node_sky_texture(
   if (use_mapping)
     p = transform(mapping, p);
 
-  if (type == "nishita_improved")
+  if (sky_type == "nishita_improved")
     Color = sky_radiance_nishita(p, nishita_data, filename);
-  if (type == "hosek_wilkie")
+  if (sky_type == "hosek_wilkie")
     Color = sky_radiance_hosek(p, phi, theta, radiance, config_x, config_y, config_z);
-  if (type == "preetham")
+  if (sky_type == "preetham")
     Color = sky_radiance_preetham(p, phi, theta, radiance, config_x, config_y, config_z);
 }
diff --git a/intern/cycles/kernel/shaders/node_vector_math.osl b/intern/cycles/kernel/shaders/node_vector_math.osl
index 218851598b4..30f0b1daf4c 100644
--- a/intern/cycles/kernel/shaders/node_vector_math.osl
+++ b/intern/cycles/kernel/shaders/node_vector_math.osl
@@ -17,7 +17,7 @@
 #include "node_math.h"
 #include "stdcycles.h"
 
-shader node_vector_math(string type = "add",
+shader node_vector_math(string math_type = "add",
                         vector Vector1 = vector(0.0, 0.0, 0.0),
                         vector Vector2 = vector(0.0, 0.0, 0.0),
                         vector Vector3 = vector(0.0, 0.0, 0.0),
@@ -25,76 +25,76 @@ shader node_vector_math(string type = "add",
                         output float Value = 0.0,
                         output vector Vector = vector(0.0, 0.0, 0.0))
 {
-  if (type == "add") {
+  if (math_type == "add") {
     Vector = Vector1 + Vector2;
   }
-  else if (type == "subtract") {
+  else if (math_type == "subtract") {
     Vector = Vector1 - Vector2;
   }
-  else if (type == "multiply") {
+  else if (math_type == "multiply") {
     Vector = Vector1 * Vector2;
   }
-  else if (type == "divide") {
+  else if (math_type == "divide") {
     Vector = safe_divide(Vector1, Vector2);
   }
-  else if (type == "cross_product") {
+  else if (math_type == "cross_product") {
     Vector = cross(Vector1, Vector2);
   }
-  else if (type == "project") {
+  else if (math_type == "project") {
     Vector = project(Vector1, Vector2);
   }
-  else if (type == "reflect") {
+  else if (math_type == "reflect") {
     Vector = reflect(Vector1, normalize(Vector2));
   }
-  else if (type == "dot_product") {
+  else if (math_type == "dot_product") {
     Value = dot(Vector1, Vector2);
   }
-  else if (type == "distance") {
+  else if (math_type == "distance") {
     Value = distance(Vector1, Vector2);
   }
-  else if (type == "length") {
+  else if (math_type == "length") {
     Value = length(Vector1);
   }
-  else if (type == "scale") {
+  else if (math_type == "scale") {
     Vector = Vector1 * Scale;
   }
-  else if (type == "normalize") {
+  else if (math_type == "normalize") {
     Vector = normalize(Vector1);
   }
-  else if (type == "snap") {
+  else if (math_type == "snap") {
     Vector = snap(Vector1, Vector2);
   }
-  else if (type == "floor") {
+  else if (math_type == "floor") {
     Vector = floor(Vector1);
   }
-  else if (type == "ceil") {
+  else if (math_type == "ceil") {
     Vector = ceil(Vector1);
   }
-  else if (type == "modulo") {
+  else if (math_type == "modulo") {
     Vector = fmod(Vector1, Vector2);
   }
-  else if (type == "wrap") {
+  else if (math_type == "wrap") {
     Vector = wrap(Vector1, Vector2, Vector3);
   }
-  else if (type == "fraction") {
+  else if (math_type == "fraction") {
     Vector = Vector1 - floor(Vector1);
   }
-  else if (type == "absolute") {
+  else if (math_type == "absolute") {
     Vector = abs(Vector1);
   }
-  else if (type == "minimum") {
+  else if (math_type == "minimum") {
     Vector = min(Vector1, Vector2);
   }
-  else if (type == "maximum") {
+  else if (math_type == "maximum") {
     Vector = max(Vector1, Vector2);
   }
-  else if (type == "sine") {
+  else if (math_type == "sine") {
     Vector = sin(Vector1);
   }
-  else if (type == "cosine") {
+  else if (math_type == "cosine") {
     Vector = cos(Vector1);
   }
-  else if (type == "tangent") {
+  else if (math_type == "tangent") {
     Vector = tan(Vector1);
   }
   else {
diff --git a/intern/cycles/kernel/shaders/node_vector_rotate.osl b/intern/cycles/kernel/shaders/node_vector_rotate.osl
index 2efe3470ae2..e99bf7d81b0 100644
--- a/intern/cycles/kernel/shaders/node_vector_rotate.osl
+++ b/intern/cycles/kernel/shaders/node_vector_rotate.osl
@@ -18,7 +18,7 @@
 #include "stdcycles.h"
 
 shader node_vector_rotate(int invert = 0,
-                          string type = "axis",
+                          string rotate_type = "axis",
                           vector VectorIn = vector(0.0, 0.0, 0.0),
                           point Center = point(0.0, 0.0, 0.0),
                           point Rotation = point(0.0, 0.0, 0.0),
@@ -26,19 +26,19 @@ shader node_vector_rotate(int invert = 0,
                           float Angle = 0.0,
                           output vector VectorOut = vector(0.0, 0.0, 0.0))
 {
-  if (type == "euler_xyz") {
+  if (rotate_type == "euler_xyz") {
     matrix rmat = (invert) ? transpose(euler_to_mat(Rotation)) : euler_to_mat(Rotation);
     VectorOut = transform(rmat, VectorIn - Center) + Center;
   }
   else {
     float a = (invert) ? -Angle : Angle;
-    if (type == "x_axis") {
+    if (rotate_type == "x_axis") {
       VectorOut = rotate(VectorIn - Center, a, point(0.0), vector(1.0, 0.0, 0.0)) + Center;
     }
-    else if (type == "y_axis") {
+    else if (rotate_type == "y_axis") {
       VectorOut = rotate(VectorIn - Center, a, point(0.0), vector(0.0, 1.0, 0.0)) + Center;
     }
-    else if (type == "z_axis") {
+    else if (rotate_type == "z_axis") {
       VectorOut = rotate(VectorIn - Center, a, point(0.0), vector(0.0, 0.0, 1.0)) + Center;
     }
     else {  // axis
diff --git a/intern/cycles/kernel/shaders/node_vector_transform.osl b/intern/cycles/kernel/shaders/node_vector_transform.osl
index 1db799cfc9e..b71c6ec4824 100644
--- a/intern/cycles/kernel/shaders/node_vector_transform.osl
+++ b/intern/cycles/kernel/shaders/node_vector_transform.osl
@@ -16,18 +16,18 @@
 
 #include "stdcycles.h"
 
-shader node_vector_transform(string type = "vector",
+shader node_vector_transform(string transform_type = "vector",
                              string convert_from = "world",
                              string convert_to = "object",
                              vector VectorIn = vector(0.0, 0.0, 0.0),
                              output vector VectorOut = vector(0.0, 0.0, 0.0))
 {
-  if (type == "vector" || type == "normal") {
+  if (transform_type == "vector" || transform_type == "normal") {
     VectorOut = transform(convert_from, convert_to, VectorIn);
-    if (type == "normal")
+    if (transform_type == "normal")
       VectorOut = normalize(VectorOut);
   }
-  else if (type == "point") {
+  else if (transform_type == "point") {
     point Point = (point)VectorIn;
     VectorOut = transform(convert_from, convert_to, Point);
   }
diff --git a/intern/cycles/kernel/shaders/node_wave_texture.osl b/intern/cycles/kernel/shaders/node_wave_texture.osl
index 874bfb8d3af..71d81dff7ec 100644
--- a/intern/cycles/kernel/shaders/node_wave_texture.osl
+++ b/intern/cycles/kernel/shaders/node_wave_texture.osl
@@ -86,7 +86,7 @@ float wave(point p_input,
 
 shader node_wave_texture(int use_mapping = 0,
                          matrix mapping = matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
-                         string type = "bands",
+                         string wave_type = "bands",
                          string bands_direction = "x",
                          string rings_direction = "x",
                          string profile = "sine",
@@ -106,7 +106,7 @@ shader node_wave_texture(int use_mapping = 0,
     p = transform(mapping, p);
 
   Fac = wave(p * Scale,
-             type,
+             wave_type,
              bands_direction,
              rings_direction,
              profile,