Add a working draft of the query

Author: jeongsoolee09

cpp/autosar/src/rules/M5-0-12/SignedCharAndUnsignedCharTypeShallOnlyBeUsedForTheStorageAndUseOfNumericValues.ql

@@ -16,23 +16,194 @@
 import cpp
 import codingstandards.cpp.autosar
 
-from Variable v, Expr aexp
+newtype TTemplatedElement =
+  TClassTemplate(TemplateClass c) or
+  TFunctionTemplate(TemplateFunction f) or
+  TVariableTemplate(TemplateVariable v)
+
+class TemplatedElement extends TTemplatedElement {
+  TemplateClass asTemplateClass() { this = TClassTemplate(result) }
+
+  TemplateFunction asTemplateFunction() { this = TFunctionTemplate(result) }
+
+  TemplateVariable asTemplateVariable() { this = TVariableTemplate(result) }
+
+  string toString() {
+    result = this.asTemplateClass().toString() or
+    result = this.asTemplateFunction().toString() or
+    result = this.asTemplateVariable().toString()
+  }
+
+  Location getLocation() {
+    result = this.asTemplateClass().getLocation() or
+    result = this.asTemplateFunction().getLocation() or
+    result = this.asTemplateVariable().getLocation()
+  }
+
+  string getName() {
+    result = this.asTemplateClass().getName() or
+    result = this.asTemplateFunction().getName() or
+    result = this.asTemplateVariable().getName()
+  }
+}
+
+newtype TTemplateInstantiation =
+  TClassTemplateInstantiation(ClassTemplateInstantiation c) or
+  TFunctionTemplateInstantiation(FunctionTemplateInstantiation f) or
+  TVariableTemplateInstantiation(VariableTemplateInstantiation v)
+
+class TemplateInstantiation extends TTemplateInstantiation {
+  ClassTemplateInstantiation asClassTemplateInstantiation() {
+    this = TClassTemplateInstantiation(result)
+  }
+
+  FunctionTemplateInstantiation asFunctionTemplateInstantiation() {
+    this = TFunctionTemplateInstantiation(result)
+  }
+
+  VariableTemplateInstantiation asVariableTemplateInstantiation() {
+    this = TVariableTemplateInstantiation(result)
+  }
+
+  string toString() {
+    result = this.asClassTemplateInstantiation().toString() or
+    result = this.asFunctionTemplateInstantiation().toString() or
+    result = this.asVariableTemplateInstantiation().toString()
+  }
+
+  Location getLocation() {
+    result = this.asClassTemplateInstantiation().getLocation() or
+    result = this.asFunctionTemplateInstantiation().getLocation() or
+    result = this.asVariableTemplateInstantiation().getLocation()
+  }
+
+  Element asElement() {
+    result = this.asClassTemplateInstantiation() or
+    result = this.asFunctionTemplateInstantiation() or
+    result = this.asVariableTemplateInstantiation()
+  }
+
+  TemplatedElement getTemplate() {
+    result.asTemplateClass() = this.asClassTemplateInstantiation().getTemplate() or
+    result.asTemplateFunction() = this.asFunctionTemplateInstantiation().getTemplate() or
+    result.asTemplateVariable() = this.asVariableTemplateInstantiation().getTemplate()
+  }
+
+  /**
+   * Gets a use of an instantiation of this template. i.e.
+   * 1. For a class template, it's where the instantiated type is used by the name.
+   * 2. For a function template, it's where the instantiated function is called.
+   * 3. For a variable template, it's where the instantiated variable is initialized.
+   */
+  Element getAUse() {
+    result = this.asClassTemplateInstantiation().getATypeNameUse() or
+    result = this.asFunctionTemplateInstantiation().getACallToThisFunction() or
+    result = this.asVariableTemplateInstantiation()
+  }
+}
+
+class ImplicitConversionFromPlainCharType extends Conversion {
+  ImplicitConversionFromPlainCharType() {
+    this.isImplicit() and
+    this.getExpr().getUnspecifiedType() instanceof PlainCharType and
+    (
+      this.getUnspecifiedType() instanceof SignedCharType or
+      this.getUnspecifiedType() instanceof UnsignedCharType
+    )
+  }
+}
+
+newtype TImplicitConversionElement =
+  TImplicitConversionOutsideTemplate(ImplicitConversionFromPlainCharType implicitConversion) {
+    not exists(TemplateInstantiation instantiation |
+      implicitConversion.isFromTemplateInstantiation(instantiation.asElement())
+    )
+  } or
+  TInstantiationOfImplicitConversionTemplate(
+    TemplateInstantiation templateInstantiation,
+    ImplicitConversionFromPlainCharType implicitConversion
+  ) {
+    implicitConversion.getEnclosingElement+() = templateInstantiation.asElement()
+  }
+
+class ImplicitConversionLocation extends TImplicitConversionElement {
+  ImplicitConversionFromPlainCharType asImplicitConversionOutsideTemplate() {
+    this = TImplicitConversionOutsideTemplate(result)
+  }
+
+  TemplateInstantiation asInstantiationOfImplicitConversionTemplate(
+    ImplicitConversionFromPlainCharType implicitConversion
+  ) {
+    this = TInstantiationOfImplicitConversionTemplate(result, implicitConversion)
+  }
+
+  predicate isImplicitConversionOutsideTemplate() {
+    exists(this.asImplicitConversionOutsideTemplate())
+  }
+
+  predicate isInstantiationOfImplicitConversionTemplate() {
+    exists(
+      TemplateInstantiation templateInstantiation,
+      ImplicitConversionFromPlainCharType implicitConversion
+    |
+      templateInstantiation = this.asInstantiationOfImplicitConversionTemplate(implicitConversion)
+    )
+  }
+
+  ImplicitConversionFromPlainCharType getImplicitConversion() {
+    result = this.asImplicitConversionOutsideTemplate() or
+    exists(TemplateInstantiation templateInstantiation |
+      this = TInstantiationOfImplicitConversionTemplate(templateInstantiation, result)
+    )
+  }
+
+  string toString() {
+    result = this.asImplicitConversionOutsideTemplate().toString() or
+    exists(ImplicitConversionFromPlainCharType implicitConversion |
+      result = this.asInstantiationOfImplicitConversionTemplate(implicitConversion).toString()
+    )
+  }
+
+  Location getLocation() {
+    result = this.asImplicitConversionOutsideTemplate().getLocation() or
+    exists(ImplicitConversionFromPlainCharType implicitConversion |
+      result = this.asInstantiationOfImplicitConversionTemplate(implicitConversion).getLocation()
+    )
+  }
+
+  Element asElement() {
+    result = this.asImplicitConversionOutsideTemplate() or
+    exists(ImplicitConversionFromPlainCharType implicitConversion |
+      result = this.asInstantiationOfImplicitConversionTemplate(implicitConversion).getAUse()
+    )
+  }
+}
+
+string getMessageTemplate(ImplicitConversionLocation implicitConversionLocation) {
+  exists(ImplicitConversionFromPlainCharType implicitConversion |
+    implicitConversion = implicitConversionLocation.getImplicitConversion()
+  |
+    implicitConversionLocation.isImplicitConversionOutsideTemplate() and
+    result =
+      "Implicit conversion of plain char $@ to " + implicitConversion.getType().getName() + "."
+    or
+    implicitConversionLocation.isInstantiationOfImplicitConversionTemplate() and
+    result =
+      "Implicit conversion of plain char $@ to " + implicitConversion.getType().getName() +
+        " from instantiating template '" +
+        implicitConversionLocation
+            .asInstantiationOfImplicitConversionTemplate(implicitConversion)
+            .getTemplate()
+            .getName() + "'."
+  )
+}
+
+from
+  ImplicitConversionLocation implicitConversionLocation,
+  ImplicitConversionFromPlainCharType implicitConversion
 where
-  not isExcluded(v,
+  not isExcluded(implicitConversionLocation.asElement(),
     StringsPackage::signedCharAndUnsignedCharTypeShallOnlyBeUsedForTheStorageAndUseOfNumericValuesQuery()) and
-  // We find cases where it is an explicitly signed char type with an assignment
-  // to a non-numeric type. NOTE: This rule addresses cases where the char type
-  // is used character data only, the rule does not explicitly cover this.
-  // Please see M5-0-11 for explicit handling of this case. Get types that are
-  // char, except for ones that are 'plain', meaning the sign is explicit.
-  (
-    v.getUnspecifiedType() instanceof SignedCharType or
-    v.getUnspecifiedType() instanceof UnsignedCharType
-  ) and
-  // Identify places where these explicitly signed types are being assigned to a
-  // non-numeric type.
-  aexp = v.getAnAssignedValue() and
-  aexp.getUnspecifiedType() instanceof CharType
-select aexp,
-  "Assignment of an non-integer type to variable $@ which is a variable with an explicitly signed char type",
-  v, v.getName()
+  implicitConversion = implicitConversionLocation.getImplicitConversion()
+select implicitConversionLocation.asElement(), getMessageTemplate(implicitConversionLocation),
+  implicitConversion.getExpr(), "expression"