Add support for editor placeholders to Clang's lexer

[arphaman]

Summary

This patch is based on the RFC that I've sent out earlier (http://lists.llvm.org/pipermail/cfe-dev/2017-April/053394.html).
It teaches Clang's Lexer to recognize the editor placeholders that are produced by some editors like Xcode when expanding code-completion results that include placeholders. When the Lexer sees a placeholder, it emits an error 'editor placeholder in source file', suppresses all diagnostics in the placeholder range and lexes the tokens in the placeholder.

This patch also includes a new compiler option called '-fsuppress-editor-placeholder-error' that surpasses the 'editor placeholder in source file' error. This option is useful for an IDE like Xcode as we don't want to display those errors as live diagnostics in the editor.

There are still certain things that can be improved. For example, in the future we may want to add support for different kinds of placeholders (e.g. typed, it would produce special typed expressions) that would actually produce a special token instead of lexing the contents of the placeholder in order to improve the parser's recovery. But they will require changes to the code-completion code as well, so I left them for later to keep this patch small.

[arphaman]

I've decided to treat each placeholder as an identifier token (like Swift) instead of just lexing the contents. This will prevent spurious errors for declaration name placeholders that have spaces or hyphens inside.

[benlangmuir]

Rather than stick ranges into the diagnostic engine, I think it would be cleaner to have the identifier have a method like isEditorPlaceholder() that can be used to avoid situations like this in a principled way, or to customize behaviour for placeholders in the parser, etc. That's how we are handling it in Swift. Using an API on the placeholder is also better for handling errors that could be caused by the placeholder but not have it as the primary location.

What do you think?

include/clang/Driver/Options.td

1473

How about -fallow-editor-placeholder? It's a little shorter, and not specific to a single error.

[arphaman]

In D32081#727450, @benlangmuir wrote:

Rather than stick ranges into the diagnostic engine, I think it would be cleaner to have the identifier have a method like isEditorPlaceholder() that can be used to avoid situations like this in a principled way, or to customize behaviour for placeholders in the parser, etc. That's how we are handling it in Swift. Using an API on the placeholder is also better for handling errors that could be caused by the placeholder but not have it as the primary location.

What do you think?

I thought about this as well. I'm not sure which way is better though. The current way is simple in the sense that we automatically suppress all diagnostics in the placeholder, so we don't have to modify the parser at all. Clang generates placeholders in a bunch of different places so I reckon there'll have to be a lot of modifications to suppress all problematic cases. Although I suppose that if we teach the parser about the most common places where placeholders could occur (e.g. expressions), that would probably suppress the majority of diagnostics that we care about. I'll try out the parser changes right now.

[arphaman]

In D32081#727511, @arphaman wrote:

In D32081#727450, @benlangmuir wrote:

Rather than stick ranges into the diagnostic engine, I think it would be cleaner to have the identifier have a method like isEditorPlaceholder() that can be used to avoid situations like this in a principled way, or to customize behaviour for placeholders in the parser, etc. That's how we are handling it in Swift. Using an API on the placeholder is also better for handling errors that could be caused by the placeholder but not have it as the primary location.

What do you think?

I thought about this as well. I'm not sure which way is better though. The current way is simple in the sense that we automatically suppress all diagnostics in the placeholder, so we don't have to modify the parser at all. Clang generates placeholders in a bunch of different places so I reckon there'll have to be a lot of modifications to suppress all problematic cases. Although I suppose that if we teach the parser about the most common places where placeholders could occur (e.g. expressions), that would probably suppress the majority of diagnostics that we care about. I'll try out the parser changes right now.

It seems that suppressing placeholders in expressions and type names would cover the a lot of the common problematic cases. What do you think about a hybrid approach: Don't suppress diagnostics in the placeholder range when we handle the placeholders in parser/sema, but do suppress the range when the placeholder isn't explicitly handled?

[benlangmuir]

What do you think about a hybrid approach: Don't suppress diagnostics in the placeholder range when we handle the placeholders in parser/sema, but do suppress the range when the placeholder isn't explicitly handled?

I'd really rather not plumb this into the diagnostics engine at all if we can avoid it. Are there cases we somehow cannot handle using the explicit checks, or is it just a question of finding all the cases?

[arphaman]

It's more about handling all of the cases, e.g. the completion results for declaration patterns with placeholders, as those can't be caught with a check at an expression/typename level.

I guess then I can catch all of the most common cases now and we can improve the suppression for the remaining cases later on.

[arphaman]

• Don't use the diagnostic engine suppression ranges, but rely on changes to parser/sema for diagnostic suppression.
• Rename the compiler flag to '-fallow-editor-placeholders'.

[arphaman]

Check if IdentifierInfo is nil in ActOnIdExpression to prevent crash.

[benlangmuir]

include/clang/Basic/IdentifierTable.h

358 ↗

(On Diff #95349)

Nitpick: There should probably be an example in the doc comment. The editor placeholder syntax isn't commonly known.

include/clang/Driver/Options.td

1478

Does the negative -fno- option need to be CC1Option? Later in this patch you seem to canonicalize on the positive form when passing to the frontend.

[arphaman]

Add comments and remove -fno-allow-editor-placeholders from CC1 options.

include/clang/Basic/Diagnostic.h

private:
 
   /// \brief Optional flag value.
   ///
   /// Some flags accept values, for instance: -Wframe-larger-than=<value> and
   /// -Rpass=<value>. The content of this string is emitted after the flag name
   /// and '='.
   std::string FlagValue;
 
+  /// The source ranges in which all diagnostics should be supressed.
+  std::vector<SourceRange> SuppressionRanges;
+
 public:
   explicit DiagnosticsEngine(IntrusiveRefCntPtr<DiagnosticIDs> Diags,
                              DiagnosticOptions *DiagOpts,
                              DiagnosticConsumer *client = nullptr,
                              bool ShouldOwnClient = true);
   DiagnosticsEngine(const DiagnosticsEngine &) = delete;
   DiagnosticsEngine &operator=(const DiagnosticsEngine &) = delete;
   ~DiagnosticsEngine();
public:
   /// \c DiagnosticsEngine, and we may be attaching a note to that diagnostic.
   void notePriorDiagnosticFrom(const DiagnosticsEngine &Other) {
     LastDiagLevel = Other.LastDiagLevel;
   }
 
   /// \brief Reset the state of the diagnostic object to its initial 
   /// configuration.
   void Reset();
-  
+  /// Specify a new source range in which all of the diagnostics will be
+  /// supressed.
+  void suppressDiagnosticsInRange(SourceRange R);
+
+  ArrayRef<SourceRange> getSuppressionRanges() const {
+    return SuppressionRanges;
+  }
+
   //===--------------------------------------------------------------------===//
   // DiagnosticsEngine classification and reporting interfaces.
   //
 
   /// \brief Determine whether the diagnostic is known to be ignored.
   ///
   /// This can be used to opportunistically avoid expensive checks when it's
   /// known for certain that the diagnostic has been suppressed at the

include/clang/Basic/DiagnosticLexKinds.td

def warn_bad_string_encoding : ExtWarn<
   "illegal character encoding in string literal">,
   InGroup<InvalidSourceEncoding>;
 def err_bad_character_encoding : Error<
   "illegal character encoding in character literal">;
 def warn_bad_character_encoding : ExtWarn<
   "illegal character encoding in character literal">,
   InGroup<InvalidSourceEncoding>;
 def err_lexing_string : Error<"failure when lexing a string">;
+def err_placeholder_in_source : Error<"editor placeholder in source file">;
 
 
 //===----------------------------------------------------------------------===//
 // PTH Diagnostics
 //===----------------------------------------------------------------------===//
 def err_invalid_pth_file : Error<
     "invalid or corrupt PTH file '%0'">;
 

include/clang/Basic/DiagnosticOptions.def

 VALUE_DIAGOPT(ConstexprBacktraceLimit, 32, DefaultConstexprBacktraceLimit)
 /// Limit number of times to perform spell checking.
 VALUE_DIAGOPT(SpellCheckingLimit, 32, DefaultSpellCheckingLimit)
 
 VALUE_DIAGOPT(TabStop, 32, DefaultTabStop) /// The distance between tab stops.
 /// Column limit for formatting message diagnostics, or 0 if unused.
 VALUE_DIAGOPT(MessageLength, 32, 0)
 
+/// True when the 'editor placeholder in source file' has to be supressed.
+DIAGOPT(SuppressEditorPlaceholderError, 1, 0)
+
 #undef DIAGOPT
 #undef ENUM_DIAGOPT
 #undef VALUE_DIAGOPT
 #undef SEMANTIC_DIAGOPT
 #undef SEMANTIC_ENUM_DIAGOPT
 #undef SEMANTIC_VALUE_DIAGOPT

include/clang/Driver/Options.td

 
 def fstrict_return : Flag<["-"], "fstrict-return">, Group<f_Group>,
   Flags<[CC1Option]>,
   HelpText<"Always treat control flow paths that fall off the end of a "
            "non-void function as unreachable">;
 def fno_strict_return : Flag<["-"], "fno-strict-return">, Group<f_Group>,
   Flags<[CC1Option]>;
 
+def fsuppress_editor_placeholder_error : Flag<["-"], "fsuppress-editor-placeholder-error">, Group<f_Group>,
+  Flags<[CC1Option]>,
+  HelpText<"Suppress the 'editor placeholder in source file' errors">;
+def fno_suppress_editor_placeholder_error : Flag<["-"], "fno-suppress-editor-placeholder-error">, Group<f_Group>,
+  Flags<[CC1Option]>;
+
 def fdebug_types_section: Flag <["-"], "fdebug-types-section">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Place debug types in their own section (ELF Only)">;
 def fno_debug_types_section: Flag<["-"], "fno-debug-types-section">, Group<f_Group>,
   Flags<[CC1Option]>;
 def fsplit_dwarf_inlining: Flag <["-"], "fsplit-dwarf-inlining">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Place debug types in their own section (ELF Only)">;
 def fno_split_dwarf_inlining: Flag<["-"], "fno-split-dwarf-inlining">, Group<f_Group>,
   Flags<[CC1Option]>;

include/clang/Lex/Lexer.h

class Lexer : public PreprocessorLexer {
 
   bool HasLeadingSpace;
 
   bool HasLeadingEmptyMacro;
 
   // CurrentConflictMarkerState - The kind of conflict marker we are handling.
   ConflictMarkerKind CurrentConflictMarkerState;
 
+  /// The pointer to the end of the current placeholder.
+  const char *CurrentPlaceholderEnd;
+
   Lexer(const Lexer &) = delete;
   void operator=(const Lexer &) = delete;
   friend class Preprocessor;
 
   void InitLexer(const char *BufStart, const char *BufPtr, const char *BufEnd);
 public:
 
   /// Lexer constructor - Create a new lexer object for the specified buffer
bool SkipLineComment       (Token &Result, const char *CurPtr,
                               bool &TokAtPhysicalStartOfLine);
   bool SkipBlockComment      (Token &Result, const char *CurPtr,
                               bool &TokAtPhysicalStartOfLine);
   bool SaveLineComment       (Token &Result, const char *CurPtr);
   
   bool IsStartOfConflictMarker(const char *CurPtr);
   bool HandleEndOfConflictMarker(const char *CurPtr);
 
+  bool lexEditorPlaceholderStart(const char *CurPtr);
+  bool lexEditorPlaceholderEnd(const char *CurPtr);
+
   bool isCodeCompletionPoint(const char *CurPtr) const;
   void cutOffLexing() { BufferPtr = BufferEnd; }
 
   bool isHexaLiteral(const char *Start, const LangOptions &LangOpts);
 
 
   /// Read a universal character name.
   ///

lib/Basic/Diagnostic.cpp

void DiagnosticsEngine::setSeverityForAll(diag::Flavor Flavor,
   Diags->getAllDiagnostics(Flavor, AllDiags);
 
   // Set the mapping.
   for (diag::kind Diag : AllDiags)
     if (Diags->isBuiltinWarningOrExtension(Diag))
       setSeverity(Diag, Map, Loc);
 }
 
+void DiagnosticsEngine::suppressDiagnosticsInRange(SourceRange R) {
+  SuppressionRanges.push_back(R);
+}
+
 void DiagnosticsEngine::Report(const StoredDiagnostic &storedDiag) {
   assert(CurDiagID == ~0U && "Multiple diagnostics in flight at once!");
 
   CurDiagLoc = storedDiag.getLocation();
   CurDiagID = storedDiag.getID();
   NumDiagArgs = 0;
 
   DiagRanges.clear();

lib/Basic/DiagnosticIDs.cpp

DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc,
   // If we are in a system header, we ignore it. We look at the diagnostic class
   // because we also want to ignore extensions and warnings in -Werror and
   // -pedantic-errors modes, which *map* warnings/extensions to errors.
   if (Diag.SuppressSystemWarnings && !ShowInSystemHeader && Loc.isValid() &&
       Diag.getSourceManager().isInSystemHeader(
           Diag.getSourceManager().getExpansionLoc(Loc)))
     return diag::Severity::Ignored;
 
+  // Check if the diagnostic is in a suppressed range.
+  if (Loc.isValid() && Diag.hasSourceManager()) {
+    const SourceManager &SM = Diag.getSourceManager();
+    for (const SourceRange &R : Diag.getSuppressionRanges()) {
+      if (Loc == R.getBegin() || Loc == R.getEnd())
+        return diag::Severity::Ignored;
+      if (SM.isBeforeInTranslationUnit(R.getBegin(), Loc) &&
+          SM.isBeforeInTranslationUnit(Loc, R.getEnd()))
+        return diag::Severity::Ignored;
+    }
+  }
+
   return Result;
 }
 
 #define GET_DIAG_ARRAYS
 #include "clang/Basic/DiagnosticGroups.inc"
 #undef GET_DIAG_ARRAYS
 
 namespace {

lib/Driver/ToolChains/Clang.cpp

if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
                     options::OPT_fno_struct_path_tbaa))
     CmdArgs.push_back("-no-struct-path-tbaa");
   if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
                    false))
     CmdArgs.push_back("-fstrict-enums");
   if (!Args.hasFlag(options::OPT_fstrict_return, options::OPT_fno_strict_return,
                     true))
     CmdArgs.push_back("-fno-strict-return");
+  if (Args.hasFlag(options::OPT_fsuppress_editor_placeholder_error,
+                   options::OPT_fno_suppress_editor_placeholder_error, false))
+    CmdArgs.push_back("-fsuppress-editor-placeholder-error");
   if (Args.hasFlag(options::OPT_fstrict_vtable_pointers,
                    options::OPT_fno_strict_vtable_pointers,
                    false))
     CmdArgs.push_back("-fstrict-vtable-pointers");
   if (!Args.hasFlag(options::OPT_foptimize_sibling_calls,
                     options::OPT_fno_optimize_sibling_calls))
     CmdArgs.push_back("-mdisable-tail-calls");
 

lib/Frontend/CompilerInvocation.cpp

Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
                                     DiagnosticOptions::DefaultTabStop, Diags);
   if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
     Opts.TabStop = DiagnosticOptions::DefaultTabStop;
     if (Diags)
       Diags->Report(diag::warn_ignoring_ftabstop_value)
       << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
   }
   Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
+  Opts.SuppressEditorPlaceholderError =
+      Args.hasArg(OPT_fsuppress_editor_placeholder_error);
   addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
   addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
 
   return Success;
 }
 
 static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
   Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);

lib/Lex/Lexer.cpp

void Lexer::InitLexer(const char *BufStart, const char *BufPtr,
   // We are not in raw mode.  Raw mode disables diagnostics and interpretation
   // of tokens (e.g. identifiers, thus disabling macro expansion).  It is used
   // to quickly lex the tokens of the buffer, e.g. when handling a "#if 0" block
   // or otherwise skipping over tokens.
   LexingRawMode = false;
 
   // Default to not keeping comments.
   ExtendedTokenMode = 0;
+
+  CurrentPlaceholderEnd = nullptr;
 }
 
 /// Lexer constructor - Create a new lexer object for the specified buffer
 /// with the specified preprocessor managing the lexing process.  This lexer
 /// assumes that the associated file buffer and Preprocessor objects will
 /// outlive it, so it doesn't take ownership of either of them.
 Lexer::Lexer(FileID FID, const llvm::MemoryBuffer *InputFile, Preprocessor &PP)
   : PreprocessorLexer(&PP, FID),
if (const char *End = FindConflictEnd(CurPtr, BufferEnd,
     // No longer in the conflict marker.
     CurrentConflictMarkerState = CMK_None;
     return true;
   }
   
   return false;
 }
 
+static const char *findPlaceholderEnd(const char *CurPtr,
+                                      const char *BufferEnd) {
+  if (CurPtr == BufferEnd)
+    return nullptr;
+  BufferEnd -= 1; // Scan until the second last character.
+  for (; CurPtr != BufferEnd; ++CurPtr) {
+    if (CurPtr[0] == '#' && CurPtr[1] == '>')
+      return CurPtr + 2;
+  }
+  return nullptr;
+}
+
+bool Lexer::lexEditorPlaceholderStart(const char *CurPtr) {
+  assert(CurPtr[-1] == '<' && CurPtr[0] == '#' && "Not a placeholder!");
+  if (!PP || CurrentPlaceholderEnd)
+    return false;
+  CurrentPlaceholderEnd = findPlaceholderEnd(CurPtr + 1, BufferEnd);
+  if (!CurrentPlaceholderEnd)
+    return false;
+  BufferPtr = CurPtr + 1;
+  if (!PP->getDiagnostics()
+           .getDiagnosticOptions()
+           .SuppressEditorPlaceholderError)
+    Diag(CurPtr - 1, diag::err_placeholder_in_source);
+  // Suppress the diagnostics in range of the editor placeholder.
+  PP->getDiagnostics().suppressDiagnosticsInRange(SourceRange(
+      FileLoc.getLocWithOffset(CurPtr - 1 - BufferStart),
+      FileLoc.getLocWithOffset(CurrentPlaceholderEnd - BufferStart)));
+  return true;
+}
+
+bool Lexer::lexEditorPlaceholderEnd(const char *CurPtr) {
+  assert(CurPtr[-1] == '#' && CurPtr[0] == '>' && "Not a placeholder!");
+  if (CurrentPlaceholderEnd != CurPtr + 1)
+    return false;
+  BufferPtr = CurPtr + 1;
+  CurrentPlaceholderEnd = nullptr;
+  return true;
+}
+
 bool Lexer::isCodeCompletionPoint(const char *CurPtr) const {
   if (PP && PP->isCodeCompletionEnabled()) {
     SourceLocation Loc = FileLoc.getLocWithOffset(CurPtr-BufferStart);
     return Loc == PP->getCodeCompletionLoc();
   }
 
   return false;
 }
if (ParsingFilename) {
         }
       }
 
       CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
       Kind = tok::l_square;
     } else if (LangOpts.Digraphs && Char == '%') {     // '<%' -> '{'
       CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
       Kind = tok::l_brace;
+    } else if (Char == '#' && lexEditorPlaceholderStart(CurPtr)) {
+      // If this is '<#' and we're in an editor placeholder, then lex the tokens
+      // in the placeholder.
+      goto LexNextToken;
     } else {
       Kind = tok::less;
     }
     break;
   case '>':
     Char = getCharAndSize(CurPtr, SizeTmp);
     if (Char == '=') {
       CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
case '#':
     if (Char == '#') {
       Kind = tok::hashhash;
       CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
     } else if (Char == '@' && LangOpts.MicrosoftExt) {  // #@ -> Charize
       Kind = tok::hashat;
       if (!isLexingRawMode())
         Diag(BufferPtr, diag::ext_charize_microsoft);
       CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
+    } else if (Char == '>' && lexEditorPlaceholderEnd(CurPtr)) {
+      goto LexNextToken;
     } else {
       // We parsed a # character.  If this occurs at the start of the line,
       // it's actually the start of a preprocessing directive.  Callback to
       // the preprocessor to handle it.
       // TODO: -fpreprocessed mode??
       if (TokAtPhysicalStartOfLine && !LexingRawMode && !Is_PragmaLexer)
         goto HandleDirective;
 

test/Driver/clang_f_opts.c

 // RUN: %clang -### -S -fno-strict-return %s 2>&1 | FileCheck -check-prefix=CHECK-NO-STRICT-RETURN %s
 // CHECK-STRICT-RETURN-NOT: "-fno-strict-return"
 // CHECK-NO-STRICT-RETURN: "-fno-strict-return"
 
 // RUN: %clang -### -S -fno-debug-info-for-profiling -fdebug-info-for-profiling %s 2>&1 | FileCheck -check-prefix=CHECK-PROFILE-DEBUG %s
 // RUN: %clang -### -S -fdebug-info-for-profiling -fno-debug-info-for-profiling %s 2>&1 | FileCheck -check-prefix=CHECK-NO-PROFILE-DEBUG %s
 // CHECK-PROFILE-DEBUG: -fdebug-info-for-profiling
 // CHECK-NO-PROFILE-DEBUG-NOT: -fdebug-info-for-profiling
+
+// RUN: %clang -### -S -fsuppress-editor-placeholder-error %s 2>&1 | FileCheck -check-prefix=CHECK-SUPPRESS-PLACEHOLDER-ERROR %s
+// RUN: %clang -### -S -fno-suppress-editor-placeholder-error %s 2>&1 | FileCheck -check-prefix=CHECK-NO-SUPPRESS-PLACEHOLDER-ERROR %s
+// CHECK-SUPPRESS-PLACEHOLDER-ERROR: -fsuppress-editor-placeholder-error
+// CHECK-NO-SUPPRESS-PLACEHOLDER-ERROR-NOT: -fsuppress-editor-placeholder-error

test/Lexer/editor-placeholder.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only  -fsuppress-editor-placeholder-error -DSUPPRESS -verify %s
+
+struct Struct {
+public:
+    void method(Struct &x);
+};
+
+void avoidPlaceholderErrors(Struct &obj) {
+    while (<#condition#>) {
+        <#statements#>
+    }
+    obj.method(<#Struct &x#>);
+#ifndef SUPPRESS
+  // expected-error@-5 {{editor placeholder in source file}}
+  // expected-error@-5 {{editor placeholder in source file}}
+  // expected-error@-4 {{editor placeholder in source file}}
+#endif
+    switch (<#expression#>) {
+        case <#constant#>:
+            <#statements#>
+#ifndef SUPPRESS
+  // expected-error@-4 {{editor placeholder in source file}}
+  // expected-error@-4 {{editor placeholder in source file}}
+  // expected-error@-4 {{editor placeholder in source file}}
+#endif
+            break;
+
+        default:
+            break;
+    }
+}
+
+void Struct::method(<#Struct &x#>, noSupressionHere) { // expected-error {{unknown type name 'noSupressionHere'}}
+#ifndef SUPPRESS
+  // expected-error@-2 {{editor placeholder in source file}}
+#endif
+}

test/Parser/placeholder-recovery.m

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 // FIXME: We could do much better with this, if we recognized
 // placeholders somehow. However, we're content with not generating
 // bogus 'archaic' warnings with bad location info.
-@protocol <#protocol name#> <NSObject> // expected-error {{expected identifier or '('}} \
-// expected-error 2{{expected identifier}} \
-// expected-warning{{protocol has no object type specified; defaults to qualified 'id'}}
-<#methods#>
+@protocol <#protocol name#> <NSObject> // expected-error {{editor placeholder in source file}}
+// expected-error@-1 {{expected identifier or '('}}
+
+<#methods#> // expected-error {{editor placeholder in source file}}
 
 @end