Merge pull request #6081 from ethereum/accept-reject

Accept reject

Author: yann300

apps/remix-ide/src/app/tabs/locales/en/editor.json

@@ -21,7 +21,7 @@
   "editor.formatCode": "Format Code",
   "editor.generateDocumentation": "Generate documentation for this function",
   "editor.generateDocumentation2": "Generate documentation for the function \"{name}\"",
-  "editor.generateDocumentationByAI": "```solidity\n {content}\n```\n You only generate the natspec documentation for the function {currentFunction} using the docstring style syntax. Only use docstring supported tags",
+  "editor.generateDocumentationByAI": "```solidity\n {content}\n```\n Generate or improve the natspec documentation for the function {currentFunction} using the supported docstring style syntax and tags. Only return the comments and the function declaration, no other text.",
   "editor.explainFunction": "Explain this function",
   "editor.explainFunctionSol": "Explain this code",
   "editor.explainFunction2": "Explain the function \"{name}\"",

libs/remix-ui/editor/src/lib/actions/editor.ts

@@ -38,7 +38,7 @@ export const reducerActions = (models = initialState, action: Action) => {
     const model = models[uri]?.model
     if (model) model.dispose()
     delete models[uri]
-    return models
+    return { ...models }
   }
   case 'ADD_DIFF': {
     if (!editors) return models

libs/remix-ui/editor/src/lib/helpers/retrieveNodesAtPosition.ts

@@ -11,4 +11,168 @@ export const retrieveNodesAtPosition = async (positionOffset: number, plugin: Pl
     }
   }
   return { nodesAtPosition, block }
-}
+}
+
+export const extractFunctionComments = (code: string, indentSize: number = 0, isSolidity: boolean = false) => {
+  // Different patterns for Solidity vs non-Solidity functions
+  const functionPattern = isSolidity
+    ? /(?:function\s+(\w+)|constructor)\s*(?:\([^)]*\))?\s*(?:public|private|internal|external)?\s*(?:view|pure|payable)?\s*(?:returns\s*\([^)]*\))?\s*(?:is\w+)?\s*{/g
+    : /(?:function\s+(\w+)|constructor|(\w+)\s*\([^)]*\)\s*(?::\s*\w+(?:<[^>]+>)?)?\s*{)/g
+
+  const functionPositions = new Map<string, { position: number, commentStart?: number, singleLineComments?: string[] }>()
+  let functionMatch
+
+  // First pass: find all function positions
+  while ((functionMatch = functionPattern.exec(code)) !== null) {
+    const functionName = functionMatch[1] || functionMatch[2] || 'constructor'
+    functionPositions.set(functionName, { position: functionMatch.index })
+  }
+
+  // Initialize functionComments with null for all functions
+  const functionComments = {}
+  for (const [functionName] of functionPositions) {
+    functionComments[functionName] = null
+  }
+
+  const multiLineCommentPattern = /\/\*\*[\s\S]*?\*\//g
+  let commentMatch
+
+  while ((commentMatch = multiLineCommentPattern.exec(code)) !== null) {
+    const commentStart = commentMatch.index
+    const commentEnd = commentStart + commentMatch[0].length
+    let nextFunction = null
+    let minDistance = Infinity
+
+    for (const [funcName, funcInfo] of functionPositions) {
+      if (funcInfo.position > commentEnd && funcInfo.position - commentEnd < minDistance) {
+        minDistance = funcInfo.position - commentEnd
+        nextFunction = funcName
+      }
+    }
+
+    if (nextFunction && minDistance < Infinity) {
+      const betweenCommentAndFunction = code.slice(commentEnd, functionPositions.get(nextFunction).position)
+      const hasOtherFunction = betweenCommentAndFunction.match(functionPattern)
+
+      if (!hasOtherFunction) {
+        functionPositions.get(nextFunction).commentStart = commentStart
+      }
+    }
+  }
+
+  for (const [functionName, funcInfo] of functionPositions) {
+    const functionStart = funcInfo.position
+    const functionStartLine = code.slice(0, functionStart).split('\n').length
+    const singleLineComments = []
+
+    let currentLine = functionStartLine - 1
+    while (currentLine > 0) {
+      const lineStart = code.split('\n').slice(0, currentLine - 1).join('\n').length + (currentLine > 1 ? 1 : 0)
+      const lineEnd = code.split('\n').slice(0, currentLine).join('\n').length
+      const line = code.slice(lineStart, lineEnd).trim()
+      if (line.startsWith('//')) {
+        singleLineComments.unshift(line.slice(2).trim())
+        currentLine--
+      } else if (line === '') {
+        currentLine--
+      } else {
+        break
+      }
+    }
+    if (singleLineComments.length > 0) {
+      funcInfo.singleLineComments = singleLineComments
+    }
+  }
+
+  for (const [functionName, funcInfo] of functionPositions) {
+    let processedComment = null
+
+    if (funcInfo.commentStart !== undefined) {
+      const comment = code.slice(funcInfo.commentStart, funcInfo.position).trim()
+
+      if (isSolidity) {
+        const betweenCommentAndFunction = code.slice(funcInfo.commentStart + comment.length, funcInfo.position)
+        const contractKeywordPos = betweenCommentAndFunction.indexOf('contract')
+
+        if (contractKeywordPos === -1) {
+          const contractCommentPattern = /\/\*\*[\s\S]*?\*\/\s*contract\s+\w+/g
+          processedComment = comment
+            .replace(contractCommentPattern, '')
+            .trim()
+          if (!processedComment.startsWith('/**')) {
+            processedComment = '/**' + processedComment
+          }
+          if (!processedComment.endsWith('*/')) {
+            processedComment = processedComment + '*/'
+          }
+
+          processedComment = processedComment.split('\n')
+            .filter(line => {
+              const trimmed = line.trim()
+              return trimmed.startsWith('*') || trimmed === '/*' || trimmed === '*/' || trimmed === '/**'
+            })
+            .join('\n')
+            .trim()
+
+          if (indentSize > 0) {
+            processedComment = applyIndentation(processedComment, indentSize)
+          }
+
+          if (!processedComment.includes('@dev') && !processedComment.includes('@param') && !processedComment.includes('@return')) {
+            processedComment = null
+          }
+        }
+      } else {
+        processedComment = comment.trim()
+        if (!processedComment.startsWith('/**')) {
+          processedComment = '/**' + processedComment
+        }
+        if (!processedComment.endsWith('*/')) {
+          processedComment = processedComment + '*/'
+        }
+        processedComment = processedComment.split('\n')
+          .filter(line => {
+            const trimmed = line.trim()
+            return trimmed.startsWith('*') || trimmed === '/*' || trimmed === '*/' || trimmed === '/**'
+          })
+          .join('\n')
+          .trim()
+
+        if (indentSize > 0) {
+          processedComment = applyIndentation(processedComment, indentSize)
+        }
+      }
+    }
+
+    if (!processedComment && funcInfo.singleLineComments && funcInfo.singleLineComments.length > 0) {
+      if (isSolidity) {
+        processedComment = '/**\n * @dev ' + funcInfo.singleLineComments.join('\n * ') + '\n */'
+      } else {
+        processedComment = '/**\n * ' + funcInfo.singleLineComments.join('\n * ') + '\n */'
+      }
+      if (indentSize > 0) {
+        processedComment = applyIndentation(processedComment, indentSize)
+      }
+    }
+
+    functionComments[functionName] = processedComment
+  }
+
+  return functionComments
+}
+
+// Helper function to apply indentation to comments
+const applyIndentation = (comment: string, indentSize: number): string => {
+  const indent = '\t'.repeat(indentSize)
+  return comment.split('\n').map(line => {
+    if (line.trim() === '') return line
+    if (line.trim() === '*/' || line.trim() === '/*') {
+      return indent + line.trim()
+    }
+    if (line.trim().startsWith('*')) {
+      const content = line.trim().slice(1).trim()
+      return indent + '* ' + content
+    }
+    return indent + line
+  }).join('\n')
+}

libs/remix-ui/editor/src/lib/remix-ui-editor.css

@@ -29,4 +29,18 @@
 
 div.monaco-list-row > span.title {
     margin-top: 12px;
+}
+
+.modifiedChangesDecoration {
+    background-color: var(--danger) !important;
+    color: var(--white) !important;
+    filter: opacity(0.1);
+    font-weight: bolder;
+}
+
+.newChangesDecoration {
+    background-color: var(--ai) !important;
+    color: var(--white) !important;
+    filter: opacity(0.1);
+    font-weight: bolder;
 }