Dec 7, 2023 · Oct 24, 2023 · Oct 24, 2023 · Oct 24, 2023 · Nov 22, 2023
diff --git a/change_notes/2023-10-24-a7-1-5-non-fundamental.md b/change_notes/2023-10-24-a7-1-5-non-fundamental.md
 * `A7-1-5` - exclude auto variables initialized with an expression of non-fundamental type. Typically this occurs when using range based for loops with arrays of non-fundamental types. For example:
   ```
   void iterate(Foo values[]) {
      for (auto value : values) { // COMPLIANT (previously false positive)
         // ...
      }
   }
   ```
diff --git a/cpp/autosar/src/rules/A7-1-5/AutoSpecifierNotUsedAppropriatelyInVariableDefinition.ql b/cpp/autosar/src/rules/A7-1-5/AutoSpecifierNotUsedAppropriatelyInVariableDefinition.ql
 import cpp
 import codingstandards.cpp.autosar

 class FundamentalType extends BuiltInType {
  FundamentalType() { not this instanceof ErroneousType and not this instanceof UnknownType }
 }

 from Variable v
 where
  not isExcluded(v,
  // exclude uninstantiated templates and rely on the instantiated templates, because an uninstantiated template may not contain the information required to determine if the usage is allowed.
  not v.isFromUninstantiatedTemplate(_) and
  not (
    //find ones where
    //Initialized by function call
    v.getInitializer().getExpr() instanceof FunctionCall
    or
    // Initialized by lambda expression
    v.getInitializer().getExpr() instanceof LambdaExpression
    or
    v.getInitializer().getExpr() instanceof ClassAggregateLiteral
    // Initialized by non-fundamental type
    not v.getInitializer().getExpr().getType() instanceof FundamentalType
  ) and
  // Exclude compiler generated variables
  not v.isCompilerGenerated()
diff --git a/cpp/autosar/test/rules/A7-1-5/AutoSpecifierNotUsedAppropriatelyInVariableDefinition.expected b/cpp/autosar/test/rules/A7-1-5/AutoSpecifierNotUsedAppropriatelyInVariableDefinition.expected
 | test.cpp:27:8:27:8 | a | Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. |
 | test.cpp:28:8:28:8 | b | Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. |
 | test.cpp:81:10:81:10 | a | Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. |
 | test.cpp:111:19:111:19 | a | Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. |
 | test.cpp:111:13:111:13 | a | Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. |
diff --git a/cpp/autosar/test/rules/A7-1-5/test.cpp b/cpp/autosar/test/rules/A7-1-5/test.cpp
  t381.test_381_1();
  t381.test_381_2();
 }

 class Foo {};
 void test_loop() {
  for (const auto a : {8, 9, 10}) {
  for (auto a : {8, 9, 10}) { // NON_COMPLIANT - a is initialized with a
                              //                 non-constant initializer
    a;
  }

  std::vector<int> v = {1, 2, 3};
  for (auto &a : v) { // COMPLIANT - a is intialized with a function call
    a;
  }

  Foo f1;
  Foo f2;
  for (auto &a : {f1, f2}) { // COMPLIANT - initialized with a non-fundamental
                             //             type
    a;
  }
 }
 }

 template <typename T> void test_template(std::vector<T> v2) {
  for (auto &a : v2) { // COMPLIANT - a is intialized with a function call
    a;
  }
 }

 void test_template_instantiation() { test_template<int>({1, 2, 3}); }
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,8 @@
		* `A7-1-5` - exclude auto variables initialized with an expression of non-fundamental type. Typically this occurs when using range based for loops with arrays of non-fundamental types. For example:
		```
		void iterate(Foo values[]) {
		for (auto value : values) { // COMPLIANT (previously false positive)
		// ...
		}
		}
		```
Original file line number	Diff line number	Diff line change
Expand Up		@@ -19,6 +19,10 @@
		import cpp
		import codingstandards.cpp.autosar

		class FundamentalType extends BuiltInType {
		FundamentalType() { not this instanceof ErroneousType and not this instanceof UnknownType }
		}

		from Variable v
		where
		not isExcluded(v,
Expand All		@@ -28,12 +32,14 @@ where
		// exclude uninstantiated templates and rely on the instantiated templates, because an uninstantiated template may not contain the information required to determine if the usage is allowed.
		not v.isFromUninstantiatedTemplate(_) and
		not (
		//find ones where
		//Initialized by function call
		v.getInitializer().getExpr() instanceof FunctionCall
		or
		// Initialized by lambda expression
		v.getInitializer().getExpr() instanceof LambdaExpression
		or
		v.getInitializer().getExpr() instanceof ClassAggregateLiteral
		// Initialized by non-fundamental type
		not v.getInitializer().getExpr().getType() instanceof FundamentalType
		) and
		// Exclude compiler generated variables
		not v.isCompilerGenerated()
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -4,4 +4,4 @@
		\| test.cpp:27:8:27:8 \| a \| Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. \|
		\| test.cpp:28:8:28:8 \| b \| Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. \|
		\| test.cpp:81:10:81:10 \| a \| Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. \|
		\| test.cpp:111:19:111:19 \| a \| Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. \|
		\| test.cpp:111:13:111:13 \| a \| Use of auto in variable definition is not the result of a function call, lambda expression, or non-fundamental type initializer. \|
Original file line number	Diff line number	Diff line change
Expand Up		@@ -106,9 +106,30 @@ void instantiate() {
		t381.test_381_1();
		t381.test_381_2();
		}

		class Foo {};
		void test_loop() {
		for (const auto a : {8, 9, 10}) {
		for (auto a : {8, 9, 10}) { // NON_COMPLIANT - a is initialized with a
		// non-constant initializer
		a;
		}

		std::vector<int> v = {1, 2, 3};
		for (auto &a : v) { // COMPLIANT - a is intialized with a function call
		a;
		}

		Foo f1;
		Foo f2;
		for (auto &a : {f1, f2}) { // COMPLIANT - initialized with a non-fundamental
		// type
		a;
		}
		}
		}

		template <typename T> void test_template(std::vector<T> v2) {
		for (auto &a : v2) { // COMPLIANT - a is intialized with a function call
		a;
		}
		}

		void test_template_instantiation() { test_template<int>({1, 2, 3}); }