resolved some warnings (DIP25 and one place where variables were shaddowing each other

examples/example1/dub.json

@@ -20,7 +20,7 @@
     },
     "configurations" : [
         {
-            "name" : "default",
+            "name" : "default"
         }, 
         {
             "name" : "console",

examples/tetris/src/gui.d

@@ -559,6 +559,7 @@ class StatusWidget : VerticalLayout {
 
     /// Measure widget according to desired width and height constraints. (Step 1 of two phase layout).
     override void measure(int parentWidth, int parentHeight) {
+        import std.algorithm: min;
         int minw = min(parentWidth, parentHeight);
         foreach(lbl; _labels) {
             lbl.fontSize = minw / 20;

src/dlangui/core/i18n.d

@@ -126,13 +126,13 @@ struct UIString {
         _value = newValue;
     }
     /** Assign raw value */
-    ref UIString opAssign(dstring rawValue) {
+    ref UIString opAssign(dstring rawValue) return {
         _value = rawValue;
         _id = null;
         return this;
     }
     /** Assign string resource id */
-    ref UIString opAssign(string ID) {
+    ref UIString opAssign(string ID) return {
         _id = ID;
         _value = null;
         return this;

src/dlangui/core/math3d.d

@@ -35,63 +35,63 @@ struct vec2 {
         vec[0] = x;
         vec[1] = y;
     }
-    ref vec2 opAssign(float[2] v) {
+    ref vec2 opAssign(float[2] v) return {
         vec = v;
         return this;
     }
-    ref vec2 opAssign(vec2 v) {
+    ref vec2 opAssign(vec2 v) return {
         vec = v.vec;
         return this;
     }
     /// fill all components of vector with specified value
-    ref vec2 clear(float v) {
+    ref vec2 clear(float v) return {
         vec[0] = vec[1] = v;
         return this;
     }
     /// add value to all components of vector
-    ref vec2 add(float v) {
+    ref vec2 add(float v) return {
         vec[0] += v;
         vec[1] += v;
         return this;
     }
     /// multiply all components of vector by value
-    ref vec2 mul(float v) {
+    ref vec2 mul(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         return this;
     }
     /// subtract value from all components of vector
-    ref vec2 sub(float v) {
+    ref vec2 sub(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         return this;
     }
     /// divide all components of vector by value
-    ref vec2 div(float v) {
+    ref vec2 div(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         return this;
     }
     /// add components of another vector to corresponding components of this vector
-    ref vec2 add(vec2 v) {
+    ref vec2 add(vec2 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         return this;
     }
     /// multiply components of this vector  by corresponding components of another vector
-    ref vec2 mul(vec2 v) {
+    ref vec2 mul(vec2 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         return this;
     }
     /// subtract components of another vector from corresponding components of this vector
-    ref vec2 sub(vec2 v) {
+    ref vec2 sub(vec2 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         return this;
     }
     /// divide components of this vector  by corresponding components of another vector
-    ref vec2 div(vec2 v) {
+    ref vec2 div(vec2 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         return this;
@@ -138,26 +138,26 @@ struct vec2 {
 
 
     /// add value to all components of vector
-    ref vec2 opOpAssign(string op : "+")(float v) {
+    ref vec2 opOpAssign(string op : "+")(float v) return {
         vec[0] += v;
         vec[1] += v;
         return this;
     }
     /// multiply all components of vector by value
-    ref vec2 opOpAssign(string op : "*")(float v) {
+    ref vec2 opOpAssign(string op : "*")(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         return this;
     }
     /// subtract value from all components of vector
-    ref vec2 opOpAssign(string op : "-")(float v) {
+    ref vec2 opOpAssign(string op : "-")(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         vec[2] -= v;
         return this;
     }
     /// divide all components of vector by value
-    ref vec2 opOpAssign(string op : "/")(float v) {
+    ref vec2 opOpAssign(string op : "/")(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         vec[2] /= v;
@@ -165,25 +165,25 @@ struct vec2 {
     }
 
     /// by component add values of corresponding components of other vector
-    ref vec2 opOpAssign(string op : "+")(const vec2 v) {
+    ref vec2 opOpAssign(string op : "+")(const vec2 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         return this;
     }
     /// by component multiply values of corresponding components of other vector
-    ref vec2 opOpAssign(string op : "*")(const vec2 v) {
+    ref vec2 opOpAssign(string op : "*")(const vec2 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         return this;
     }
     /// by component subtract values of corresponding components of other vector
-    ref vec2 opOpAssign(string op : "-")(const vec2 v) {
+    ref vec2 opOpAssign(string op : "-")(const vec2 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         return this;
     }
     /// by component divide values of corresponding components of other vector
-    ref vec2 opOpAssign(string op : "/")(const vec2 v) {
+    ref vec2 opOpAssign(string op : "/")(const vec2 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         return this;
@@ -292,76 +292,76 @@ struct vec3 {
         vec[1] = y;
         vec[2] = z;
     }
-    ref vec3 opAssign(float[3] v) {
+    ref vec3 opAssign(float[3] v) return {
         vec = v;
         return this;
     }
-    ref vec3 opAssign(vec3 v) {
+    ref vec3 opAssign(vec3 v) return {
         vec = v.vec;
         return this;
     }
-    ref vec3 opAssign(float x, float y, float z) {
+    ref vec3 opAssign(float x, float y, float z) return {
         vec[0] = x;
         vec[1] = y;
         vec[2] = z;
         return this;
     }
     /// fill all components of vector with specified value
-    ref vec3 clear(float v) {
+    ref vec3 clear(float v) return {
         vec[0] = vec[1] = vec[2] = v;
         return this;
     }
     /// add value to all components of vector
-    ref vec3 add(float v) {
+    ref vec3 add(float v) return {
         vec[0] += v;
         vec[1] += v;
         vec[2] += v;
         return this;
     }
     /// multiply all components of vector by value
-    ref vec3 mul(float v) {
+    ref vec3 mul(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         vec[2] *= v;
         return this;
     }
     /// subtract value from all components of vector
-    ref vec3 sub(float v) {
+    ref vec3 sub(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         vec[2] -= v;
         return this;
     }
     /// divide all components of vector by value
-    ref vec3 div(float v) {
+    ref vec3 div(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         vec[2] /= v;
         return this;
     }
     /// add components of another vector to corresponding components of this vector
-    ref vec3 add(vec3 v) {
+    ref vec3 add(vec3 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         vec[2] += v.vec[2];
         return this;
     }
     /// multiply components of this vector  by corresponding components of another vector
-    ref vec3 mul(vec3 v) {
+    ref vec3 mul(vec3 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         vec[2] *= v.vec[2];
         return this;
     }
     /// subtract components of another vector from corresponding components of this vector
-    ref vec3 sub(vec3 v) {
+    ref vec3 sub(vec3 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         vec[2] -= v.vec[2];
         return this;
     }
     /// divide components of this vector  by corresponding components of another vector
-    ref vec3 div(vec3 v) {
+    ref vec3 div(vec3 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         vec[2] /= v.vec[2];
@@ -599,22 +599,22 @@ struct vec4 {
         vec[2] = v.vec[2];
         vec[3] = 1.0f;
     }
-    ref vec4 opAssign(const float[4] v) {
+    ref vec4 opAssign(const float[4] v) return {
         vec = v;
         return this;
     }
-    ref vec4 opAssign(const vec4 v) {
+    ref vec4 opAssign(const vec4 v) return {
         vec = v.vec;
         return this;
     }
-    ref vec4 opAssign(float x, float y, float z, float w) {
+    ref vec4 opAssign(float x, float y, float z, float w) return {
         vec[0] = x;
         vec[1] = y;
         vec[2] = z;
         vec[3] = w;
         return this;
     }
-    ref vec4 opAssign(const vec3 v) {
+    ref vec4 opAssign(const vec3 v) return {
         vec[0] = v.vec[0];
         vec[1] = v.vec[1];
         vec[2] = v.vec[2];
@@ -624,12 +624,12 @@ struct vec4 {
 
 
     /// fill all components of vector with specified value
-    ref vec4 clear(float v) {
+    ref vec4 clear(float v) return {
         vec[0] = vec[1] = vec[2] = vec[3] = v;
         return this;
     }
     /// add value to all components of vector
-    ref vec4 add(float v) {
+    ref vec4 add(float v) return {
         vec[0] += v;
         vec[1] += v;
         vec[2] += v;
@@ -637,7 +637,7 @@ struct vec4 {
         return this;
     }
     /// multiply all components of vector by value
-    ref vec4 mul(float v) {
+    ref vec4 mul(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         vec[2] *= v;
@@ -645,7 +645,7 @@ struct vec4 {
         return this;
     }
     /// subtract value from all components of vector
-    ref vec4 sub(float v) {
+    ref vec4 sub(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         vec[2] -= v;
@@ -653,7 +653,7 @@ struct vec4 {
         return this;
     }
     /// divide all components of vector by value
-    ref vec4 div(float v) {
+    ref vec4 div(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         vec[2] /= v;
@@ -661,7 +661,7 @@ struct vec4 {
         return this;
     }
     /// add components of another vector to corresponding components of this vector
-    ref vec4 add(const vec4 v) {
+    ref vec4 add(const vec4 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         vec[2] += v.vec[2];
@@ -669,7 +669,7 @@ struct vec4 {
         return this;
     }
     /// multiply components of this vector  by corresponding components of another vector
-    ref vec4 mul(vec4 v) {
+    ref vec4 mul(vec4 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         vec[2] *= v.vec[2];
@@ -677,7 +677,7 @@ struct vec4 {
         return this;
     }
     /// subtract components of another vector from corresponding components of this vector
-    ref vec4 sub(vec4 v) {
+    ref vec4 sub(vec4 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         vec[2] -= v.vec[2];
@@ -685,7 +685,7 @@ struct vec4 {
         return this;
     }
     /// divide components of this vector  by corresponding components of another vector
-    ref vec4 div(vec4 v) {
+    ref vec4 div(vec4 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         vec[2] /= v.vec[2];
@@ -694,7 +694,7 @@ struct vec4 {
     }
 
     /// add value to all components of vector
-    vec4 opBinary(string op : "+")(float v) const {
+    vec4 opBinary(string op : "+")(float v) const return {
         vec4 res = this;
         res.vec[0] += v;
         res.vec[1] += v;
@@ -703,7 +703,7 @@ struct vec4 {
         return res;
     }
     /// multiply all components of vector by value
-    vec4 opBinary(string op : "*")(float v) const {
+    vec4 opBinary(string op : "*")(float v) const return {
         vec4 res = this;
         res.vec[0] *= v;
         res.vec[1] *= v;
@@ -712,7 +712,7 @@ struct vec4 {
         return res;
     }
     /// subtract value from all components of vector
-    vec4 opBinary(string op : "-")(float v) const {
+    vec4 opBinary(string op : "-")(float v) const return {
         vec4 res = this;
         res.vec[0] -= v;
         res.vec[1] -= v;
@@ -721,7 +721,7 @@ struct vec4 {
         return res;
     }
     /// divide all components of vector by value
-    vec4 opBinary(string op : "/")(float v) const {
+    vec4 opBinary(string op : "/")(float v) const return {
         vec4 res = this;
         res.vec[0] /= v;
         res.vec[1] /= v;
@@ -731,7 +731,7 @@ struct vec4 {
     }
 
     /// add value to all components of vector
-    ref vec4 opOpAssign(string op : "+")(float v) {
+    ref vec4 opOpAssign(string op : "+")(float v) return {
         vec[0] += v;
         vec[1] += v;
         vec[2] += v;
@@ -739,7 +739,7 @@ struct vec4 {
         return this;
     }
     /// multiply all components of vector by value
-    ref vec4 opOpAssign(string op : "*")(float v) {
+    ref vec4 opOpAssign(string op : "*")(float v) return {
         vec[0] *= v;
         vec[1] *= v;
         vec[2] *= v;
@@ -747,7 +747,7 @@ struct vec4 {
         return this;
     }
     /// subtract value from all components of vector
-    ref vec4 opOpAssign(string op : "-")(float v) {
+    ref vec4 opOpAssign(string op : "-")(float v) return {
         vec[0] -= v;
         vec[1] -= v;
         vec[2] -= v;
@@ -755,7 +755,7 @@ struct vec4 {
         return this;
     }
     /// divide all components of vector by value
-    ref vec4 opOpAssign(string op : "/")(float v) {
+    ref vec4 opOpAssign(string op : "/")(float v) return {
         vec[0] /= v;
         vec[1] /= v;
         vec[2] /= v;
@@ -764,7 +764,7 @@ struct vec4 {
     }
 
     /// by component add values of corresponding components of other vector
-    ref vec4 opOpAssign(string op : "+")(const vec4 v) {
+    ref vec4 opOpAssign(string op : "+")(const vec4 v) return {
         vec[0] += v.vec[0];
         vec[1] += v.vec[1];
         vec[2] += v.vec[2];
@@ -772,7 +772,7 @@ struct vec4 {
         return this;
     }
     /// by component multiply values of corresponding components of other vector
-    ref vec4 opOpAssign(string op : "*")(const vec4 v) {
+    ref vec4 opOpAssign(string op : "*")(const vec4 v) return {
         vec[0] *= v.vec[0];
         vec[1] *= v.vec[1];
         vec[2] *= v.vec[2];
@@ -780,7 +780,7 @@ struct vec4 {
         return this;
     }
     /// by component subtract values of corresponding components of other vector
-    ref vec4 opOpAssign(string op : "-")(const vec4 v) {
+    ref vec4 opOpAssign(string op : "-")(const vec4 v) return {
         vec[0] -= v.vec[0];
         vec[1] -= v.vec[1];
         vec[2] -= v.vec[2];
@@ -788,7 +788,7 @@ struct vec4 {
         return this;
     }
     /// by component divide values of corresponding components of other vector
-    ref vec4 opOpAssign(string op : "/")(const vec4 v) {
+    ref vec4 opOpAssign(string op : "/")(const vec4 v) return {
         vec[0] /= v.vec[0];
         vec[1] /= v.vec[1];
         vec[2] /= v.vec[2];
@@ -799,7 +799,7 @@ struct vec4 {
 
 
     /// add value to all components of vector
-    vec4 opBinary(string op : "+")(const vec4 v) const {
+    vec4 opBinary(string op : "+")(const vec4 v) const return {
         vec4 res = this;
         res.vec[0] += v.vec[0];
         res.vec[1] += v.vec[1];
@@ -808,7 +808,7 @@ struct vec4 {
         return res;
     }
     /// subtract value from all components of vector
-    vec4 opBinary(string op : "-")(const vec4 v) const {
+    vec4 opBinary(string op : "-")(const vec4 v) const return {
         vec4 res = this;
         res.vec[0] -= v.vec[0];
         res.vec[1] -= v.vec[1];
@@ -831,7 +831,7 @@ struct vec4 {
     }
 
     /// returns vector with all components which are negative of components for this vector
-    vec4 opUnary(string op : "-")() const {
+    vec4 opUnary(string op : "-")() const return {
         vec4 ret = this;
         ret[0] = -vec[0];
         ret[1] = -vec[1];
@@ -860,7 +860,7 @@ struct vec4 {
     }
 
     /// returns normalized copy of this vector
-    @property vec4 normalized() {
+    @property vec4 normalized() return {
         vec4 res = this;
         res.normalize();
         return res;
@@ -920,15 +920,15 @@ struct mat4 {
         m[0..16] = v[0..16];
     }
 
-    ref mat4 opAssign(const ref mat4 v) {
+    ref mat4 opAssign(const ref mat4 v) return {
         m[0..16] = v.m[0..16];
         return this;
     }
-    ref mat4 opAssign(const  mat4 v) {
+    ref mat4 opAssign(const  mat4 v) return {
         m[0..16] = v.m[0..16];
         return this;
     }
-    ref mat4 opAssign(const float[16] v) {
+    ref mat4 opAssign(const float[16] v) return {
         m[0..16] = v[0..16];
         return this;
     }
@@ -992,7 +992,7 @@ struct mat4 {
         m[3*4 + 3] = 0.0f;
     }
 
-    ref mat4 lookAt(const vec3 eye, const vec3 center, const vec3 up) {
+    ref mat4 lookAt(const vec3 eye, const vec3 center, const vec3 up) return {
         vec3 forward = (center - eye).normalized();
         vec3 side = vec3.crossProduct(forward, up).normalized();
         vec3 upVector = vec3.crossProduct(side, forward);
@@ -1082,13 +1082,13 @@ struct mat4 {
         return inverse;
     }
 
-    ref mat4 setLookAt(const vec3 eye, const vec3 center, const vec3 up) {
+    ref mat4 setLookAt(const vec3 eye, const vec3 center, const vec3 up) return {
         setIdentity();
         lookAt(eye, center, up);
         return this;
     }
 
-    ref mat4 translate(const vec3 v) {
+    ref mat4 translate(const vec3 v) return {
         m[3*4 + 0] += m[0*4 + 0] * v.x + m[1*4 + 0] * v.y + m[2*4 + 0] * v.z;
         m[3*4 + 1] += m[0*4 + 1] * v.x + m[1*4 + 1] * v.y + m[2*4 + 1] * v.z;
         m[3*4 + 2] += m[0*4 + 2] * v.x + m[1*4 + 2] * v.y + m[2*4 + 2] * v.z;
@@ -1096,7 +1096,7 @@ struct mat4 {
         return this;
     }
 
-    ref mat4 translate(float x, float y, float z) {
+    ref mat4 translate(float x, float y, float z) return {
         m[3*4 + 0] += m[0*4 + 0] * x + m[1*4 + 0] * y + m[2*4 + 0] * z;
         m[3*4 + 1] += m[0*4 + 1] * x + m[1*4 + 1] * y + m[2*4 + 1] * z;
         m[3*4 + 2] += m[0*4 + 2] * x + m[1*4 + 2] * y + m[2*4 + 2] * z;
@@ -1274,31 +1274,31 @@ struct mat4 {
     }
 
     /// 2d index by row, col
-    ref float opIndex(int y, int x) {
+    ref float opIndex(int y, int x) return {
         return m[y*4 + x];
     }
 
     /// 2d index by row, col
-    float opIndex(int y, int x) const {
+    float opIndex(int y, int x) const return {
         return m[y*4 + x];
     }
 
     /// scalar index by rows then (y*4 + x)
-    ref float opIndex(int index) {
+    ref float opIndex(int index) return {
         return m[index];
     }
 
     /// scalar index by rows then (y*4 + x)
-    float opIndex(int index) const {
+    float opIndex(int index) const return {
         return m[index];
     }
 
     /// set to identity: fill all items of matrix with zero except main diagonal items which will be assigned to 1.0f
-    ref mat4 setIdentity() {
+    ref mat4 setIdentity() return {
         return setDiagonal(1.0f);
     }
     /// set to diagonal: fill all items of matrix with zero except main diagonal items which will be assigned to v
-    ref mat4 setDiagonal(float v) {
+    ref mat4 setDiagonal(float v) return {
         for (int x = 0; x < 4; x++) {
             for (int y = 0; y < 4; y++) {
                 if (x == y)
@@ -1310,13 +1310,13 @@ struct mat4 {
         return this;
     }
     /// fill all items of matrix with specified value
-    ref mat4 fill(float v) {
+    ref mat4 fill(float v) return {
         foreach(ref f; m)
             f = v;
         return this;
     }
     /// fill all items of matrix with zero
-    ref mat4 setZero() {
+    ref mat4 setZero() return {
         foreach(ref f; m)
             f = 0.0f;
         return this;
@@ -1355,25 +1355,25 @@ struct mat4 {
     }
 
     /// inplace rotate around Z axis
-    ref mat4 rotatez(float angle) {
+    ref mat4 rotatez(float angle) return {
         return rotate(angle, 0, 0, 1);
     }
 
     /// inplace rotate around X axis
-    ref mat4 rotatex(float angle) {
+    ref mat4 rotatex(float angle) return {
         return rotate(angle, 1, 0, 0);
     }
 
     /// inplace rotate around Y axis
-    ref mat4 rotatey(float angle) {
+    ref mat4 rotatey(float angle) return {
         return rotate(angle, 0, 1, 0);
     }
 
-    ref mat4 rotate(float angle, const vec3 axis) {
+    ref mat4 rotate(float angle, const vec3 axis) return {
         return rotate(angle, axis.x, axis.y, axis.z);
     }
 
-    ref mat4 rotate(float angle, float x, float y, float z) {
+    ref mat4 rotate(float angle, float x, float y, float z) return {
         if (angle == 0.0f)
             return this;
         mat4 m;
@@ -1467,19 +1467,19 @@ struct mat4 {
         return this;
     }
 
-    ref mat4 rotateX(float angle) {
+    ref mat4 rotateX(float angle) return {
         return rotate(angle, 1, 0, 0);
     }
 
-    ref mat4 rotateY(float angle) {
+    ref mat4 rotateY(float angle) return {
         return rotate(angle, 0, 1, 0);
     }
 
-    ref mat4 rotateZ(float angle) {
+    ref mat4 rotateZ(float angle) return {
         return rotate(angle, 0, 0, 1);
     }
 
-    ref mat4 scale(float x, float y, float z) {
+    ref mat4 scale(float x, float y, float z) return {
         m[0*4 + 0] *= x;
         m[0*4 + 1] *= x;
         m[0*4 + 2] *= x;
@@ -1495,7 +1495,7 @@ struct mat4 {
         return this;
     }
 
-    ref mat4 scale(float v) {
+    ref mat4 scale(float v) return {
         m[0*4 + 0] *= v;
         m[0*4 + 1] *= v;
         m[0*4 + 2] *= v;
@@ -1515,7 +1515,7 @@ struct mat4 {
         return this;
     }
 
-    ref mat4 scale(const vec3 v) {
+    ref mat4 scale(const vec3 v) return {
         m[0*4 + 0] *= v.x;
         m[0*4 + 1] *= v.x;
         m[0*4 + 2] *= v.x;

src/dlangui/graphics/scene/objimport.d

@@ -23,7 +23,7 @@ struct ObjModelImport {
 
     MeshRef mesh;
 
-    protected float[] parseFloatList(Token[] tokens, int maxItems = 3, float padding = 0) {
+    protected float[] parseFloatList(Token[] tokens, int maxItems = 3, float padding = 0) return {
         int i = 0;
         int sgn = 1;
         foreach(t; tokens) {

src/dlangui/graphics/scene/scene3d.d

@@ -116,8 +116,8 @@ class Scene3d : Node3d {
 bool visit(Node3d node, bool delegate(Node3d node) visitor) {
     if (!node.visible)
         return false;
-    bool res = visitor(node);
+
-    if (res)
+    if (visitor(node))
         return true;
     foreach(child; node.children) {
         bool res = visit(child, visitor);