 
     heuristics_met_count >= 2
   end
+
+  defp create_issue_really?(location, tokens, ast, issue_meta) do
+    result =
+      find_current_prev_next_token(tokens, location)
+      |> IO.inspect(label: "tokens")
+
+    find_ast_elements(ast, result)
+    |> IO.inspect(label: "ast")
+
+    # analyse_ast_and_tokens_together
+
+    true
+  end
+
+  # TOKENS
+
+  defp find_current_prev_next_token(tokens, location) do
+    location_tuple = {location[:line_no], location[:column], location[:trigger]}
+
+    IO.inspect(location_tuple, label: "location_tuple")
+
+    [result] =
+      tokens
+      |> traverse_prev_current_next(&matching_location(location_tuple, &1, &2, &3, &4), [])
+
+    result
+  end
+
+  defp traverse_prev_current_next(tokens, callback, acc) do
+    tokens
+    |> case do
+      [prev | [current | [next | rest]]] ->
+        acc = callback.(prev, current, next, acc)
+
+        traverse_prev_current_next([current | [next | rest]], callback, acc)
+
+      _ ->
+        acc
+    end
+  end
+
+  defp matching_location(
+         {line_no, column, trigger},
+         prev,
+         {_, {line_no, column, _}, trigger} = current,
+         next,
+         acc
+       ) do
+    acc ++ [{prev, current, next}]
+  end
+
+  defp matching_location(_, _prev, _current, _next, acc) do
+    acc
+  end
+
+  # AST
+
+  defp find_ast_elements(ast, {prev, current, next}) do
+    position = Credo.Code.Token.position(current)
+
+    Credo.Code.prewalk(ast, &find_token(&1, &2, current, position), [])
+  end
+
+  defp find_token(
+         {_, meta, _} = ast,
+         acc,
+         token,
+         {line_no_start, _col_start, line_no_end, _col_end}
+       ) do
+    if meta[:line] >= line_no_start and meta[:line] <= line_no_end do
+      if ast_matches_token?(ast, token) do
+        {ast, acc ++ [ast]}
+      else
+        {ast, acc}
+      end
+    else
+      {ast, acc}
+    end
+  end
+
+  defp find_token(ast, acc, _token, _position) do
+    {ast, acc}
+  end
+
+  defp ast_matches_token?({atom, _, _} = ast, {_, _, atom} = token) do
+    # this is not enough, since there could be many :+ or :- in a single line
+    # we have to find the exact match
+    true
+  end
+
+  defp ast_matches_token?(ast, token) do
+    IO.inspect(ast, label: "ast")
+    IO.inspect(token, label: "token")
+    IO.puts("")
+
+    false
+  end
 end

  end

  defp issues_for(expected, source_file, params) do
    issue_meta = IssueMeta.for(source_file, params)

    issue_locations =
      expected
      |> @collector.find_locations_not_matching(source_file)
      |> Enum.reject(&ignored?(&1[:trigger], params))
      |> Enum.filter(&create_issue?(&1, issue_meta))

    Enum.map(issue_locations, fn location ->
      format_issue(

    "There are no spaces around operators most of the time, but here there are."
  end

  defp ignored?(location, params) do
    ignored_triggers = Params.get(params, :ignore, @default_params)

    Enum.member?(ignored_triggers, location[:trigger])
  end

  defp create_issue?(location, tokens, ast, issue_meta) do
    line_no = location[:line_no]

    line =
      issue_meta
      |> IssueMeta.source_file()
      |> SourceFile.line_at(line_no)

    if create_issue?(line, location[:column], location[:trigger]) do
      create_issue_really?(location, tokens, ast, issue_meta)
    end
  end

  # Don't create issues for `c = -1`
