Added check for position of &/* for types

We attempt to validate that the */& for pointer/reference types are
attached to the variable rather than the type. For example should be int
*x; rather than int* x;

We attempt to check this by looking for things that are at the very
start of the line and not in brackets to avoid picking up cases where
the * or & is used as a binary operator.

We can still miss cases inside a function declaration.

Updated the coding standard to also explicityl mention this preference

Author: thk123

CODING_STANDARD

@@ -17,6 +17,9 @@ Whitespaces:
   Exceptions: Spaces around &&, || and <<
 - Space after comma (parameter lists, argument lists, ...)
 - Space after colon inside 'for'
+- For pointers and references, the */& should be attached to the variable name
+  as oppposed to the tyep. E.g. for a pointer to an int the syntax would be:
+    `int *x;`
 - No whitespaces at end of line
 - No whitespaces in blank lines
 - Put argument lists on next line (and ident 2 spaces) if too long

regression/cpp-linter/pointer-type1/main.cpp

@@ -0,0 +1,37 @@
+/*******************************************************************\
+
+Module: Lint Examples
+
+Author: Thomas Kiley, thomas@diffblue.com
+
+\*******************************************************************/
+
+/*******************************************************************\
+
+Function: fun
+
+ Inputs:
+
+ Outputs:
+
+ Purpose:
+
+\*******************************************************************/
+
+static void fun()
+{
+  bool *x=nullptr; // Valid
+  bool* x=nullptr; // Invalid
+
+  int &x=nullptr; // Valid
+  int& x=nullptr; // Invalid
+
+  int y=at*bt; // Valid
+
+  // Probably valid - could be a pointer to type yt or a
+  // variable called yt multilied by z. Would have to know
+  // it is a function call rather than a function declaration
+  foo(
+    x,
+    yt*z);
+}

regression/cpp-linter/pointer-type1/test.desc

@@ -0,0 +1,8 @@
+CORE
+main.cpp
+
+^main\.cpp:24:  Pointer type name must have \* attached to the type name  \[whitespace/operators\] \[4\]$
+^main\.cpp:27:  Reference type name must have & attached to the type name  \[whitespace/operators\] \[4\]$
+^Total errors found: 2$
+^SIGNAL=0$
+--

scripts/cpplint.py

@@ -1547,34 +1547,28 @@ def IsTemplateArgumentList_DB(clean_lines, linenum, pos):
 
     return True
 
-def OpenExpression(clean_lines, linenum, pos):
-  """If input points to ) or } or ] or >, finds the position that opens it.
-
-  If lines[linenum][pos] points to a ')' or '}' or ']' or '>', finds the
-  linenum/pos that correspond to the closing of the expression.
-
-  Essentially a mirror of what CloseExpression does
+def ForceOpenExpression(clean_lines, linenum, pos, bracket):
+  """Find an opening bracket matching the specified closing bracket
 
-  TODO(tkiley): could probably be merged with CloseExpression
+  Search starting at the position for a matching closing bracket of the
+  same type as bracket.
 
   Args:
     clean_lines: A CleansedLines instance containing the file.
     linenum: The number of the line to check.
     pos: A position on the line.
+    bracket: The style of bracket to match
 
   Returns:
     A tuple (line, linenum, pos) pointer *to* the closing brace, or
     (line, len(lines), -1) if we never find a close.  Note we ignore
     strings and comments when matching; and the line we return is the
     'cleansed' line at linenum.
   """
-
   line = clean_lines.elided[linenum]
-  if (line[pos] not in ')}]>'):
-    return (line, clean_lines.NumLines(), -1)
 
   # Check first line
-  (end_pos, stack) = FindStartOfExpressionInLine(line, pos , [])
+  (end_pos, stack) = FindStartOfExpressionInLine(line, pos , [bracket])
   if end_pos > -1:
     return (line, linenum, end_pos)
 
@@ -1589,6 +1583,37 @@ def OpenExpression(clean_lines, linenum, pos):
   # Did not find end of expression before end of file, give up
   return (line, clean_lines.NumLines(), -1)
 
+def OpenExpression(clean_lines, linenum, pos):
+  """If input points to ) or } or ] or >, finds the position that opens it.
+
+  If lines[linenum][pos] points to a ')' or '}' or ']' or '>', finds the
+  linenum/pos that correspond to the closing of the expression.
+
+  Essentially a mirror of what CloseExpression does
+
+  Calls ForceOpenExpression with the bracket type pointed at
+
+  TODO(tkiley): could probably be merged with CloseExpression
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    pos: A position on the line.
+
+  Returns:
+    A tuple (line, linenum, pos) pointer *to* the closing brace, or
+    (line, len(lines), -1) if we never find a close.  Note we ignore
+    strings and comments when matching; and the line we return is the
+    'cleansed' line at linenum.
+  """
+
+  line = clean_lines.elided[linenum]
+  if (line[pos] not in ')}]>'):
+    return (line, clean_lines.NumLines(), -1)
+  else:
+    return ForceOpenExpression(clean_lines, linenum, pos-1, line[pos])
+
+
 def FindEndOfExpressionInLine(line, startpos, stack):
   """Find the position just after the end of current parenthesized expression.
 
@@ -3656,6 +3681,48 @@ def CheckOperatorSpacing(filename, clean_lines, linenum, error):
     error(filename, linenum, 'whitespace/operators', 4,
           'Extra space for operator %s' % match.group(1))
 
+def CheckPointerReferenceSpacing(filename, clean_lines, linenum, error):
+  """Checks the */& are attached to variable names rather than types
+
+  A pointer or reference type should have the */& attached to the variable
+  name rather than the type. I.e. a pointer to an int should be:
+
+      int *var_name;
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Find types by looking for word_names that are at the start of the line
+  # If there are followed by a * or & (after an optional ' const')
+  # then they appear to be a reference/pointer type with it attached to
+  # the type rather than the variable
+  wrong_type_match = Search(r'^\s*([\w_])+( const)?(?P<type>[&\*])\s*\w', line)
+
+  if wrong_type_match:
+    # This still could be a false positive, we must
+    # check that we are not inside brackets as then could be just be
+    # operators (multiply and logical AND)
+    pos = wrong_type_match.start(1)
+    _, _, opening_pos = ForceOpenExpression(clean_lines, linenum, pos, ')')
+
+    # If we don't find a matching close brace then we aren't in brackets
+    # so can assume this is a type with the * or & attached to it
+    if opening_pos == -1:
+      op_type = wrong_type_match.group('type')
+      op_word = ""
+      if op_type == '*':
+        op_word = 'Pointer'
+      else:
+        op_word = 'Reference'
+      error(filename, linenum, 'whitespace/operators', 4,
+        op_word + ' type name must have ' + op_type + ' attached to the type name')
+
+
 
 def CheckParenthesisSpacing(filename, clean_lines, linenum, error):
   """Checks for horizontal spacing around parentheses.
@@ -4671,6 +4738,7 @@ def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state,
   CheckAccess(filename, clean_lines, linenum, nesting_state, error)
   CheckSpacing(filename, clean_lines, linenum, nesting_state, error)
   CheckOperatorSpacing(filename, clean_lines, linenum, error)
+  CheckPointerReferenceSpacing(filename, clean_lines, linenum, error)
   CheckParenthesisSpacing(filename, clean_lines, linenum, error)
   CheckCommaSpacing(filename, clean_lines, linenum, error)
   CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error)