#1224 Проверяет отсутствие кода после асинхронного вызова

CHANGELOG.md

@@ -32,6 +32,7 @@
 - Проверка наличия префикса расширения в методе расширения.
 - Устаревшая процедура (функция) расположена вне области "УстаревшиеПроцедурыИФункции"
 - Использован обработчик событий, подключаемый из кода и не содержащий префикса "Подключаемый_"
+- Проверка отсутствия кода после асинхронного вызова
 
 #### Запросы
 

bundles/com.e1c.v8codestyle.bsl/markdown/code-after-async-call.md

@@ -0,0 +1,24 @@
+# The asynchronous method is not followed by lines of code
+
+In the asynchronous approach the method is called as usual, but control returns to the caller before the asynchronous 
+method is completed. After that, execution of the caller continues. 
+
+## Noncompliant Code Example
+
+```bsl
+Text = "Warning text";
+ShowMessageBox( , Text);
+Message("Warning is closed");
+```
+
+## Compliant Solution
+
+```bsl
+Text = "Warning text";
+Await DoMessageBoxAsync(Text);
+Message("Warning is closed");
+```
+
+## See
+
+- [Synchronous and asynchronous operations](https://kb.1ci.com/1C_Enterprise_Platform/Guides/Developer_Guides/1C_Enterprise_8.3.19_Developer_Guide/Chapter_4._1C_Enterprise_language/4.7._Queries/4.7.9._Synchronous_and_asynchronous_operations/)

bundles/com.e1c.v8codestyle.bsl/markdown/ru/code-after-async-call.md

@@ -0,0 +1,54 @@
+# Код расположен после асинхронного вызова
+
+При асинхронном подходе вызов метода выполняется как обычно, но управление возвращается вызывающему коду до того, 
+как асинхронный метод завершит свою работу. После этого вызывающий код продолжает свое выполнение.
+Особенность асинхронного выполнения: исполнение на стороне вызывающего кода продолжится до того, 
+как полностью закончилось исполнение вызванного метода.
+
+Для правильного решения нужно вынести весь код, который должен быть выполнен после выполнения асинхронного действия, 
+в экспортный метод и указать его имя в обработке оповещения, которая будет вызвана после завершения асинхронного действия. 
+Или использовать асинхронность через обещания, например, Ждать ПредупреждениеАсинх(Текст).
+
+## Неправильно
+
+```bsl
+Текст = "Текст предупреждения";
+ПоказатьПредупреждение( , Текст);
+Сообщить("Закрыли предупреждение");
+```
+
+```bsl
+ПоказатьПредупреждение(,ТекстПредупреждения);
+Отказ = Истина;
+```
+
+## Правильно
+
+```bsl
+Текст = "Текст предупреждения";
+Ждать ПредупреждениеАсинх(Текст);
+Сообщить("Закрыли предупреждение");
+```
+
+```bsl
+&НаКлиенте
+Процедура Команда1(Команда)
+    Оповещение = Новый ОписаниеОповещения("ПредупреждениеЗавершение", ЭтотОбъект);
+    Текст = "Текст предупреждения";
+    ПоказатьПредупреждение(Оповещение, Текст);
+КонецПроцедуры
+
+&НаКлиенте
+Процедура ПредупреждениеЗавершение(ДополнительныеПараметры) Экспорт
+    Сообщить("Закрыли предупреждение");
+КонецПроцедуры;
+```
+
+```bsl
+Отказ = Истина;
+ПоказатьПредупреждение(,ТекстПредупреждения);
+```
+
+## См.
+
+- [Синхронные и асинхронные методы работы](https://its.1c.ru/db/v8319doc#bookmark:dev:TI000001505)

bundles/com.e1c.v8codestyle.bsl/plugin.xml

@@ -347,6 +347,10 @@
             category="com.e1c.v8codestyle.bsl"
             class="com.e1c.v8codestyle.internal.bsl.ExecutableExtensionFactory:com.e1c.v8codestyle.bsl.check.DeprecatedProcedureOutsideDeprecatedRegionCheck">
       </check>
+      <check
+            category="com.e1c.v8codestyle.bsl"
+            class="com.e1c.v8codestyle.internal.bsl.ExecutableExtensionFactory:com.e1c.v8codestyle.bsl.check.CodeAfterAsyncCallCheck">
+      </check>
    </extension>
    <extension
          point="org.eclipse.core.runtime.preferences">

bundles/com.e1c.v8codestyle.bsl/src/com/e1c/v8codestyle/bsl/IAsyncInvocationProvider.java

@@ -0,0 +1,34 @@
+/*******************************************************************************
+ * Copyright (C) 2023, 1C-Soft LLC and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     1C-Soft LLC - initial API and implementation
+ *******************************************************************************/
+package com.e1c.v8codestyle.bsl;
+
+import java.util.Collection;
+import java.util.Map;
+
+import com._1c.g5.v8.dt.platform.version.Version;
+
+/**
+ * Platform context asynchronic methods provider
+ *
+ * @author Artem Iliukhin
+ */
+public interface IAsyncInvocationProvider
+{
+
+    // Global context methods
+    Collection<String> getAsyncInvocationNames(Version version);
+
+    // Methods with a list of types in which they are used
+    Map<String, Collection<String>> getAsyncTypeMethodNames(Version version);
+
+}

bundles/com.e1c.v8codestyle.bsl/src/com/e1c/v8codestyle/bsl/check/CodeAfterAsyncCallCheck.java

@@ -0,0 +1,263 @@
+/*******************************************************************************
+ * Copyright (C) 2023, 1C-Soft LLC and others.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     1C-Soft LLC - initial API and implementation
+ *******************************************************************************/
+package com.e1c.v8codestyle.bsl.check;
+
+import static com._1c.g5.v8.dt.bsl.model.BslPackage.Literals.INVOCATION;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.EcoreUtil2;
+import org.eclipse.xtext.naming.IQualifiedNameConverter;
+
+import com._1c.g5.v8.dt.bsl.common.IBslPreferences;
+import com._1c.g5.v8.dt.bsl.model.BslPackage;
+import com._1c.g5.v8.dt.bsl.model.Conditional;
+import com._1c.g5.v8.dt.bsl.model.DynamicFeatureAccess;
+import com._1c.g5.v8.dt.bsl.model.EmptyStatement;
+import com._1c.g5.v8.dt.bsl.model.Expression;
+import com._1c.g5.v8.dt.bsl.model.FeatureAccess;
+import com._1c.g5.v8.dt.bsl.model.IfStatement;
+import com._1c.g5.v8.dt.bsl.model.Invocation;
+import com._1c.g5.v8.dt.bsl.model.LoopStatement;
+import com._1c.g5.v8.dt.bsl.model.PreprocessorConditional;
+import com._1c.g5.v8.dt.bsl.model.PreprocessorItemStatements;
+import com._1c.g5.v8.dt.bsl.model.ReturnStatement;
+import com._1c.g5.v8.dt.bsl.model.SimpleStatement;
+import com._1c.g5.v8.dt.bsl.model.Statement;
+import com._1c.g5.v8.dt.bsl.model.StaticFeatureAccess;
+import com._1c.g5.v8.dt.bsl.model.TryExceptStatement;
+import com._1c.g5.v8.dt.core.platform.IResourceLookup;
+import com._1c.g5.v8.dt.platform.version.IRuntimeVersionSupport;
+import com._1c.g5.v8.dt.platform.version.Version;
+import com._1c.g5.wiring.ServiceAccess;
+import com.e1c.g5.v8.dt.check.CheckComplexity;
+import com.e1c.g5.v8.dt.check.ICheckParameters;
+import com.e1c.g5.v8.dt.check.components.BasicCheck;
+import com.e1c.g5.v8.dt.check.settings.IssueSeverity;
+import com.e1c.g5.v8.dt.check.settings.IssueType;
+import com.e1c.v8codestyle.bsl.IAsyncInvocationProvider;
+import com.e1c.v8codestyle.check.CommonSenseCheckExtension;
+import com.e1c.v8codestyle.internal.bsl.BslPlugin;
+import com.google.common.collect.Lists;
+import com.google.inject.Inject;
+
+/**
+ * Checks that the asynchronous method is not followed by lines of code,
+ * since in this case the specified lines of code are executed immediately,
+ * without waiting for the asynchronous method to execute.
+ *
+ * @author Artem Iliukhin
+ */
+public final class CodeAfterAsyncCallCheck
+    extends BasicCheck
+{
+
+    private static final String STATEMENT_NAME_RU = "Ждать"; //$NON-NLS-1$
+    private static final String STATEMENT_NAME = "Await"; //$NON-NLS-1$
+    private static final String CHECK_ID = "code-after-async-call"; //$NON-NLS-1$
+    private final IResourceLookup resourceLookup;
+    private final IAsyncInvocationProvider asyncInvocationProvider;
+
+    @Inject
+    public CodeAfterAsyncCallCheck(IResourceLookup resourceLookup, IBslPreferences bslPreferences,
+        IQualifiedNameConverter qualifiedNameConverter, IAsyncInvocationProvider asyncInvocationProvider)
+    {
+        super();
+        this.resourceLookup = resourceLookup;
+        this.asyncInvocationProvider = asyncInvocationProvider;
+    }
+
+    @Override
+    public String getCheckId()
+    {
+        return CHECK_ID;
+    }
+
+    @Override
+    protected void configureCheck(CheckConfigurer builder)
+    {
+        builder.title(Messages.CodeAfterAsyncCallCheck_Title)
+            .description(Messages.CodeAfterAsyncCallCheck_Description)
+            .complexity(CheckComplexity.NORMAL)
+            .severity(IssueSeverity.MAJOR)
+            .issueType(IssueType.WARNING)
+            .extension(new CommonSenseCheckExtension(getCheckId(), BslPlugin.PLUGIN_ID))
+            .module()
+            .checkedObjectType(INVOCATION);
+    }
+
+    @Override
+    protected void check(Object object, ResultAcceptor resultAceptor, ICheckParameters parameters,
+        IProgressMonitor monitor)
+    {
+
+        IProject project = resourceLookup.getProject((EObject)object);
+
+        IRuntimeVersionSupport runtimeVersionSupport = ServiceAccess.get(IRuntimeVersionSupport.class);
+        Version version = runtimeVersionSupport.getRuntimeVersion(project);
+
+        Invocation inv = (Invocation)object;
+        FeatureAccess featureAccess = inv.getMethodAccess();
+        if (featureAccess instanceof StaticFeatureAccess)
+        {
+            Collection<String> asyncMethodsNames = asyncInvocationProvider.getAsyncInvocationNames(version);
+            if (asyncMethodsNames.contains(featureAccess.getName()))
+            {
+                addIssue(resultAceptor, inv);
+            }
+        }
+        else if (featureAccess instanceof DynamicFeatureAccess)
+        {
+            Map<String, Collection<String>> names = asyncInvocationProvider.getAsyncTypeMethodNames(version);
+            if (names.containsKey(featureAccess.getName()))
+            {
+                addIssue(resultAceptor, inv);
+            }
+        }
+    }
+
+    private void addIssue(ResultAcceptor resultAceptor, Invocation inv)
+    {
+        Statement statement = getStatementFromInvoc(inv);
+        if (statement != null && isPreviousStatementAwait(statement))
+        {
+            statement = getNextStatement(statement);
+            if (statement != null && !(statement instanceof ReturnStatement)
+                && !(statement instanceof EmptyStatement))
+            {
+                resultAceptor.addIssue(Messages.CodeAfterAsyncCallCheck_Issue, statement);
+            }
+        }
+    }
+
+    private Statement getStatementFromInvoc(Invocation invocation)
+    {
+        EObject container = invocation.eContainer();
+        while (!(container instanceof Statement))
+        {
+            container = container.eContainer();
+        }
+        return container instanceof Statement ? (Statement)container : null;
+    }
+
+    private boolean isPreviousStatementAwait(Statement statement)
+    {
+        Iterator<EObject> it = EcoreUtil2.getAllContainers(statement).iterator();
+        while (it.hasNext())
+        {
+            EObject container = it.next();
+            if (container instanceof PreprocessorConditional)
+            {
+                continue;
+            }
+            List<Statement> st = getContainer(container);
+            if (st != null)
+            {
+                int index = st.indexOf(statement);
+                if (index > 0 && index - 1 < st.size())
+                {
+                    Statement awaitStatement = st.get(index - 1);
+                    if (awaitStatement instanceof SimpleStatement)
+                    {
+                        Expression left = ((SimpleStatement)awaitStatement).getLeft();
+                        if (left instanceof StaticFeatureAccess)
+                        {
+                            String name = ((StaticFeatureAccess)left).getName();
+                            if (STATEMENT_NAME.equalsIgnoreCase(name) || STATEMENT_NAME_RU.equalsIgnoreCase(name))
+                            {
+                                return true;
+                            }
+                        }
+                    }
+
+                    return awaitStatement != null;
+                }
+            }
+        }
+        return false;
+    }
+
+    private Statement getNextStatement(Statement statement)
+    {
+        Iterator<EObject> it = EcoreUtil2.getAllContainers(statement).iterator();
+        while (it.hasNext())
+        {
+            EObject container = it.next();
+            if (container instanceof PreprocessorConditional)
+            {
+                continue;
+            }
+            List<Statement> st = getContainer(container);
+            if (st != null)
+            {
+                int index = st.indexOf(statement);
+                if (index != -1 && index + 1 < st.size())
+                {
+                    return st.get(index + 1);
+                }
+            }
+        }
+        return null;
+    }
+
+    private List<Statement> getContainer(EObject container)
+    {
+        List<Statement> st = null;
+        if (container instanceof LoopStatement)
+        {
+            st = ((LoopStatement)container).getStatements();
+        }
+        else if (container instanceof Conditional)
+        {
+            st = ((Conditional)container).getStatements();
+        }
+        else if (container instanceof IfStatement)
+        {
+            st = ((IfStatement)container).getElseStatements();
+        }
+        else if (container instanceof TryExceptStatement)
+        {
+            st = getStatementsFromContainer((TryExceptStatement)container);
+        }
+        else if (container instanceof PreprocessorItemStatements)
+        {
+            st = ((PreprocessorItemStatements)container).getStatements();
+        }
+        else
+        {
+            st = getStatementsFromContainer(container);
+        }
+        return st;
+    }
+
+    private List<Statement> getStatementsFromContainer(TryExceptStatement container)
+    {
+        List<Statement> res = Lists.newArrayList();
+        res.addAll(container.getTryStatements());
+        res.addAll(container.getExceptStatements());
+        return res;
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<Statement> getStatementsFromContainer(EObject container)
+    {
+        Object obj = container.eGet(BslPackage.Literals.BLOCK__STATEMENTS);
+        return obj instanceof List ? (List<Statement>)obj : null;
+    }
+}