From 6232bd82ed9457e4c80b067077d1de11b68270ec Mon Sep 17 00:00:00 2001
From: =?utf8?q?Yann=20C=C3=A9bron?= <yann.cebron@jetbrains.com>
Date: Wed, 12 Aug 2020 17:25:29 +0200
Subject: [PATCH] ProcessingContext: fix javadoc formatting

GitOrigin-RevId: 7c0c27a91ad4d750030668ffde568db12806d26d
---
 .../src/com/intellij/util/ProcessingContext.java     | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/platform/util/src/com/intellij/util/ProcessingContext.java b/platform/util/src/com/intellij/util/ProcessingContext.java
index 732597592f39..eeb92aedcd40 100644
--- a/platform/util/src/com/intellij/util/ProcessingContext.java
+++ b/platform/util/src/com/intellij/util/ProcessingContext.java
@@ -1,4 +1,4 @@
-// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
+// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.intellij.util;
 
 import com.intellij.openapi.util.Key;
@@ -12,19 +12,19 @@ import java.util.Map;
  * A wrapper around map, allowing to put and get values by keys in a type-safe way. Used in various extension implementations
  * to manage temporary state. For example:
  * <ul>
- * <li>When creating ElementPattern, processing context may be used to cache some intermediate data
+ * <li>When creating {@code ElementPattern}, processing context may be used to cache some intermediate data
  * to be shared between pattern parts.</li>
- * <li>Some extensions (e.g, PsiReferenceProvider, CompletionContributors) use per-pattern registration. That allows to use
- * ElementPattern#save to put matched objects into processing contexts and then retrieve those objects inside extension implementation
+ * <li>Some extensions (e.g, {@code PsiReferenceProvider}, {@code CompletionContributors}) use per-pattern registration. That allows to use
+ * {@code ElementPattern#save} to put matched objects into processing contexts and then retrieve those objects inside extension implementation
  * after the matching is complete.</li>
  * </ul>
  * 
  * Simple processing context can contain a shared processing context inside, which should be used when iterating over several patterns 
  * or extensions, possibly from different plugins. They may still wish to reuse some cached information that a previous extension has already calculated.
- * <p/>
+ * <p>
  * In this case, a separate ProcessingContext object is created for each of those extensions, but the same {@link SharedProcessingContext}
  * is passed to their constructors. To reuse shared context, extensions are required to work with {@link #getSharedContext()} result.
- * <p/>
+ * </p>
  * Not thread-safe.
  *
  * @see #get(Key) 
-- 
2.32.0